{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"right\" style=\"text-align: right\"><i>Peter Norvig<br>2012, 2020, 2021</i></div>\n",
    "\n",
    "# The Unfinished Game ... of Risk\n",
    "\n",
    "[Keith Devlin](https://web.stanford.edu/~kdevlin/)'s [book](https://www.amazon.com/Unfinished-Game-Pascal-Fermat-Seventeenth-Century/dp/0465018963) [*The Unfinished Game*](https://wordplay.blogs.nytimes.com/2015/12/14/devlin-unfinished-game/) describes how Fermat and Pascal discovered the rules of probability that guide gambling in games. The question they confronted was: what if a gambling game is interrupted, but one player is in the lead by a certain score. How much of the pot should the leader get?\n",
    "\n",
    "My friends and I faced a similar question when a game of [*Risk*](https://www.ultraboardgames.com/risk/game-rules.php) ran on too long (as they often do) and we were unable to finish. Player **A**  was poised to make a sweeping attack on player **D**, whose territories were arranged in such a way that **A** could attack from one territory to the next without ever having to branch off.  We wrote down the number of **A**'s massed armies, **72**, and the number of armies in **D**'s successive territories: **22, 8, 2, 2, 2, 7, 1, 1, 3, 1, 2, 3, 5, 1.** What is the probability that **A** can capture all these territories?\n",
    "\n",
    "![](https://www.ultraboardgames.com/risk/gfx/board.jpg)\n",
    "\n",
    "______\n",
    "\n",
    "# Terminology\n",
    "\n",
    "Let's explain some *Risk* [rules](https://www.ultraboardgames.com/risk/game-rules.php) and terminology:\n",
    "\n",
    "- A **battle** is when armies from one territory attack an enemy neighboring territory. A roll of dice determines which armies perish:\n",
    "  - The attacker will roll 3 dice if possible (but no more than the number of armies in the attacking territory minus one).\n",
    "  - The defender will roll 2 dice if possible (or only one die if they have only one army defending). \n",
    "  - The **outcome** of the battle is determined by comparing the highest die from each of the two players, with the defender losing an army if the attacker's die is higher, and the attacker losing an army if tied or lower. Then if both sides rolled at least two dice, we do the same comparison with the second highest die on each side. \n",
    "  - When a battle kills off the last defender in a territory, the attackers **occupy** the territory. They must leave behind one army, but can move the rest in.  \n",
    "\n",
    "- A **campaign** consists of a sequence of battles and occupations. In this notebook we will consider only a **chain campaign**, in which attackers invade successive enemy territories in order, always moving all their remaining armies into each captured territory, never branching, and never changing strategy based on the outcome of a battle. The attackers **win** the campaign if they occupy all the territories. The attackers **lose** if there are any remaining defenders and only one remaining attacker, who by rule cannot attack. \n",
    "\n",
    "\n",
    "\n",
    "With that out of the way, we're ready for some Python implementation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing      import List, Iterable\n",
    "from collections import Counter\n",
    "from functools   import lru_cache\n",
    "import random\n",
    "import itertools\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Representing the State of a Campaign\n",
    "\n",
    "I will represent the **state of a campaign** as a tuple where the first element is the number of attacking armies, and subsequent elements are the number of defenders in each successive territory. Thus we can represent the start state of our unfinished campaign as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "State = tuple\n",
    "\n",
    "start = State((72, 22, 8, 2, 2, 2, 7, 1, 1, 3, 1, 2, 3, 5, 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I'll define the following functions on states: \n",
    "- `A(state)`: the number of attackers in a state.\n",
    "- `D(state)`: the number of defenders in the defender's first territory (or `0` if there are no defenders at all).\n",
    "- `allD(state)`: the tuple of numbers of defenders in each territory.\n",
    "- `update(state, dead)`: a new state reflecting the aftermath of a battle that leads to  `dead` armies, where `dead` is a two-element tuple of (attackers-who-died, defenders-who-died). The attackers will occupy the first territory if all the defenders in the first territory died.  Note that `dead` is a slightly different usage of `State`, counting the number of deaths rather than the number of living armies."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def A(state)    -> int:   \"Attackers\";       return state[0]\n",
    "def D(state)    -> int:   \"First defenders\"; return state[1] if allD(state) else 0\n",
    "def allD(state) -> tuple: \"All defenders\";   return state[1:]\n",
    "\n",
    "Deaths = State # A kind of state where (A, D) means that A attackers and D defenders died\n",
    "\n",
    "def update(state, dead: Deaths) -> State:\n",
    "    \"\"\"Update the `state` of a campaign to reflect the`dead` in a battle.\"\"\"\n",
    "    a, d, ds = A(state) - A(dead), D(state) - D(dead), allD(state)[1:]\n",
    "    if d: # Can't occupy first territory if there are defenders there \n",
    "        return State((a, d, *ds))\n",
    "    else: # Occupy territory, leaving 1 behind\n",
    "        return State((a - 1, *ds))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "72"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A(start)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "22"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D(start)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(22, 8, 2, 2, 2, 7, 1, 1, 3, 1, 2, 3, 5, 1)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "allD(start)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Rolling the Dice and the Outcome of a Single Battle\n",
    "\n",
    "We'll represent a roll of the dice with a list of integers; for example the attacker might roll `[2, 6, 1]` with three dice. The function `random_roll(n)` gives a random outcome for rolling `n` dice. The function `battle_deaths`, when given the specific sets of dice rolled by attacker and defender in a battle, returns a two-element `State` tuple that gives the number of attackers and defenders who perish in the battle."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "die  = (1, 2, 3, 4, 5, 6)\n",
    "Dice = List[int] # a list of die rolls, like [2, 6, 1]\n",
    "\n",
    "def random_roll(n) -> Dice:\n",
    "    \"\"\"Roll n dice randomly.\"\"\"\n",
    "    return [random.choice(die) for _ in range(n)]\n",
    "\n",
    "def battle_deaths(A_dice: Dice, D_dice: Dice) -> Deaths:\n",
    "    \"\"\"How many (attacker, defender) armies perish as the result of these dice?\"\"\"\n",
    "    dead = Counter('D' if a > d else 'A'\n",
    "                   for a, d in zip(sorted(A_dice, reverse=True), \n",
    "                                   sorted(D_dice, reverse=True)))\n",
    "    return Deaths((dead['A'], dead['D']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([5, 5, 4], [5, 1], (1, 1))"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Example battle\n",
    "A_dice = random_roll(3)\n",
    "D_dice = random_roll(2)\n",
    "A_dice, D_dice, battle_deaths(A_dice, D_dice)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Monte Carlo Simulation of a Campaign\n",
    "\n",
    "A [**Monte Carlo simulation**](https://en.wikipedia.org/wiki/Monte_Carlo_method) makes random choices at every choice point (here, every dice roll), and reports on the outcome. \n",
    "\n",
    "The function `simulate_campaign` rolls random dice for a battle until we've reached a terminal state where there can be no more battles (either because the defenders have all been defeated, or because the attackers do not have the two armies necessary to launch an attack)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def simulate_campaign(state) -> State:\n",
    "    \"\"\"Simulate a campaign with random rolls, returning the final state.\"\"\"\n",
    "    while not terminal(state):\n",
    "        dead  = battle_deaths(random_roll(min(3, A(state))), \n",
    "                              random_roll(min(2, D(state))))\n",
    "        state = update(state, dead)\n",
    "    return state\n",
    "\n",
    "def terminal(state) -> bool: \n",
    "    \"\"\"Is the game over?\"\"\"\n",
    "    return A(state) < 2 or not D(state)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Finishing the Unfinished Game (Randomly)\n",
    "\n",
    "**Let's see who wins!**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(11,)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simulate_campaign(start)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That final state says that the attackers won—there are 11 attackers and no defenders left. \n",
    "\n",
    "# Predicting the Unfinished Game: Estimating Probabilities\n",
    "\n",
    "But what if we want to know not just who won that one game, but what is the **probability** that the attackers win? Monte Carlo simulation answers that question by repeating a simulation many times and **summarizing** all the final outcomes. The summary is in the form of a **probability distribution**, a mapping of `{outcome_state: probability}` pairs, which I have implemented as `ProbDist`. I implemented `ProbDist` as a subclass of `Counter`, with the restriction that the values are normalized to sum to 1. (I realize that the name  `Counter` suggests integer counts, but that's not a requirement, and `Counter` has a nicer API than `dict`, including  a default value of 0  and the `most_common` method.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ProbDist(Counter): \n",
    "    \"A Probability Distribution.\"\n",
    "    def __init__(self, *args):\n",
    "        Counter.__init__(self, *args)\n",
    "        total = sum(self.values())\n",
    "        for x in self:\n",
    "            self[x] /= total "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ProbDist({'H': 0.1,\n",
       "          'E': 0.1,\n",
       "          'L': 0.3,\n",
       "          'O': 0.2,\n",
       "          'W': 0.1,\n",
       "          'R': 0.1,\n",
       "          'D': 0.1})"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ProbDist('HELLOWORLD') # example probability distribution over 10 letters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The higher-order function `monte_carlo` works with any random simulation function, calling it `k` times, each time passing in a `start` state, and collecting the `k` outcome states in a `ProbDist`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def monte_carlo(simulation, start, k=1000) -> ProbDist:\n",
    "    \"Call simulation(start) repeatedly (k times) and return a ProbDist of outcomes.\"\n",
    "    return ProbDist(simulation(start) for _ in range(k))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we run the campaign \n",
    "simulation 10 times and see the summary of outcomes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ProbDist({(5,): 0.2,\n",
       "          (8,): 0.2,\n",
       "          (22,): 0.1,\n",
       "          (21,): 0.1,\n",
       "          (11,): 0.1,\n",
       "          (0, 5, 1): 0.1,\n",
       "          (13,): 0.1,\n",
       "          (1, 1, 1): 0.1})"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "monte_carlo(simulate_campaign, start, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And here we run it 1,000 times and report the probability that the attackers win:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def attacker_win_probability(dist: ProbDist) -> float: \n",
    "    \"\"\"The probability that the attackers win the campaign.\"\"\"\n",
    "    return sum(dist[s] for s in dist if not allD(s))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8190000000000004"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "attacker_win_probability(monte_carlo(simulate_campaign, start, 1000))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How accurate is that result? We can run it again and compare:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8130000000000003"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "attacker_win_probability(monte_carlo(simulate_campaign, start))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alernatively, we could  do some math: the standard deviation of the expected value of a [binomial variable](https://www.mathsisfun.com/data/binomial-distribution.html) is $\\sqrt{p(1-p)/n}$, where $p$ is the true probability of one of the two outcomes and $n$ is the number of samples. In our case $\\sqrt{0.8(1-0.8)/1000}$ gives a standard deviation of about 1%. So we can be pretty confident (but not certain) \n",
    "that the true percentage is somewhere between 77% and 86%.\n",
    "\n",
    "We could get better accuracy at the cost of increased computing time.  It took about half a second to do 1,000 simulations; to get the standard deviation down by a factor of 10 to 0.1% would require 100 times more computing time (because of the square root in the formula), about a minute. To get to 0.01% would require 100 minutes.  \n",
    "\n",
    "# Monte Carlo Simulation versus Exact Probability Calculation\n",
    "\n",
    "An alternative to the Monte Carlo approach is an approach that explicitly calculates the exact probability distribution of the final state of ther campaign. The differences between the two approaches are:\n",
    "\n",
    "- The **Monte Carlo approach** deals with a **single current state**, using random dice rolls to decide how that state changes. At the end of a simulated campaign we get a single final state, and we repeat the simulation to get an **estimated** probability distribution over final states.\n",
    "\n",
    "- The **exact probability calculation approach** deals with a **probability distribution over states**, right from the start. At each dice roll, every possible outcome is considered, and the probability distribution is updated to reflect all the outcomes and their probabilities. At the end of the campaign we have an **exact** probability distribution over all possible final states (well, exact at least to the limits of floating point precision; if you need even more precision, use `fractions.Fraction`).\n",
    "\n",
    "In deciding whether to use the exact calculation approach, there are three considerations:\n",
    "\n",
    "- **Is it worth the effort?** If I only wanted to know whether the attackers chance of winning is more or less than 50%, then the Monte Carlo approach is the quickest way to answer the question. The code will be simple and straightforward.  If I need 0.0001% precision on the win probability, then exact calculation is called for.\n",
    "- **Is it possible?** The exact calculation approach only works for **finite games**. \n",
    "- **Is it feasible?** Computation may take too long if there are too many possible states of the game.\n",
    "\n",
    "**Worth the effort?** In general, the code for an exact calculation is more complex than for a Monte Carlo simulation, and thus it will take more time to write and debug the code. Monte Carlo code deals with the single current state of the simulation, for example: \n",
    "\n",
    "     while not terminal(state):\n",
    "     \n",
    "But in the exact calculation we need to consider every possible states (referenced in a loop):\n",
    "\n",
    "    while any(not terminal(state) for state in probdist):\n",
    "    \n",
    "Adding all these loops to the code makes it more complex. After the shared basics of representing states and battle outcomes, we need just just 10 non-comment lines of code to implement the Monte Carlo method (in `simulate_campaign`, `monte_carlo`, and `random_roll`), but 22 lines to implement exact calculation (in `campaign_probdist`, `battle_deaths_probdist`, `battle_update_probdist`, and `all_rolls`).\n",
    "\n",
    "**Possible?** Imagine a *Risk* rule change where if the attackers roll three 6s and the defneders roll two 6s, then both sides *gain* an army. For the Monte Carlo simulation it would be trivial to add a single `if` statement to handle this rule, and the expected run time of the program would hardly change. But with the exact calculation everything has changed, because we now have an  **infinite** game: no matter how far ahead we look, there will always be some possible states that have not terminated. (To deal with these we would have to make some compromises, such as stopping the calculation when there are still some nonterminal states, as long as they have very low probability in total.)\n",
    "\n",
    "**Feasible?** Imagine a rule change where before each battle, every army independently has the option to take one of ten possible actions (e.g. to move to a safe neighboring territory). Then with 100 armies, the very first move has $10^{100}$ outcomes, meaning that the probability distribution requires more states than the number of atoms in the universe. (To deal with this we would either stick with the Monte Carlo simulation, or a variant of it such as [particle filtering](https://en.wikipedia.org/wiki/Particle_filter) in which we maintain a **sample** of several possible states–more than a single state, but less than the complete state distribution.)\n",
    "\n",
    " The *Risk* campaign problem as it stands leads to a very efficient exact probability calculation (possible, feasible, and, IMHO, worth it). If there are $n$ total armies to start, then there are fewer than $n^2$ possible states, and the game can last no more than $n$ moves. With $n$ in the range of a few hundred, computation takes less than a second; much faster and more accurate than doing 100,000 simulations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exact Probability Distribution over a Battle\n",
    "\n",
    "The function `battle_deaths` was defined above to return the specific death counts for a specific dice roll. \n",
    "\n",
    "Now we'll define `battle_deaths_probdist` to give a probability distribution over all possible battle outcomes, corresponding to all possible dice rolls. The input to `battle_deaths_probdist` is a state giving the number of attacking and defending armies for just this one battle (*not* the total number of attacking and defending armies in the current state). Thus, the attackers will always be 3, 2, or 1, and the defenders will always be 2 or 1. I define it this way so that I can **cache** the results and reuse them in subsequent battles, for efficiency."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "@lru_cache()\n",
    "def battle_deaths_probdist(state) -> ProbDist:\n",
    "    \"\"\"A probability distribution of deaths in a battle.\n",
    "    State is (A, D) where 1 <= A <= 3 and 1 <= D <= 2.\"\"\"\n",
    "    return ProbDist(battle_deaths(A_dice, D_dice)\n",
    "                    for A_dice in all_rolls(A(state))\n",
    "                    for D_dice in all_rolls(D(state)))\n",
    "\n",
    "def all_rolls(n) -> Iterable[Dice]: \n",
    "    \"\"\"All possible rolls of `n` dice.\"\"\"\n",
    "    return itertools.product(die, repeat=n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ProbDist({(2, 0): 0.2925668724279835,\n",
       "          (1, 1): 0.3357767489711934,\n",
       "          (0, 2): 0.37165637860082307})"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "battle_deaths_probdist((3, 2)) # Three attacker dice against two defender dice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exact Probability Distribution over a Campaign\n",
    "\n",
    "Our old function `campaign` is mimiced by `campaign_probdist`, except that the former updates a `State` whereas the later updates a `ProbDist`. We start with certainty: there is a 100% chance that we are initially in the `start` state. But the [fog of war](https://en.wikipedia.org/wiki/Fog_of_war) means that uncertainty soon arises: we don't know how the dice will land, so we don't know the outcome of the very first battle. Subsequent battles add more uncertainty. \n",
    "\n",
    "`campaign_probdist` calls  `battle_update_probdist` to update the probability distribution to account for one battle, in all the possible ways it can turn out. The key line in `battle_update_probdist` is\n",
    "\n",
    "    outcomes[update(state, dead)] += probdist[state] * dead_probdist[dead]\n",
    "    \n",
    "which tells us to consider the outcome in which `dead` is the number of attackers and defenders that die in a battle, and to update `state` with those death counts, and increment the probability of that updated outcome by the product of the probability of `state` and the probability of `dead` given `state`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def campaign_probdist(start: State) -> ProbDist:\n",
    "    \"\"\"Probability distribution for all outcomes of a campaign.\"\"\"\n",
    "    probdist = ProbDist({start: 1.0})\n",
    "    while any(not terminal(state) for state in probdist):\n",
    "        probdist = battle_update_probdist(probdist)\n",
    "    return probdist\n",
    "\n",
    "def battle_update_probdist(probdist) -> ProbDist:\n",
    "    \"\"\"For every possible campaign state in the `probdist`, consider the outcomes of a battle. \n",
    "    Combine these all into one updated `outcomes` ProbDist.\"\"\"\n",
    "    outcomes = ProbDist()\n",
    "    for state in probdist:\n",
    "        if terminal(state): # `state` carries through unchanged to `outcomes`\n",
    "            outcomes[state] += probdist[state] \n",
    "        else: # Replace `state` with all possible outcomes from a battle\n",
    "            dead_probdist = battle_deaths_probdist((min(3, A(state) - 1), min(2, D(state))))\n",
    "            for dead in dead_probdist:\n",
    "                outcomes[update(state, dead)] += probdist[state] * dead_probdist[dead]\n",
    "    return outcomes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Finishing the Unfinished Game (Exactly)\n",
    "\n",
    "What is the exact probability of  winning the unfinished game?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8105485936352178"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "attacker_win_probability(campaign_probdist(start))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The attackers defeat all the defenders 81.05% of the time. \n",
    "\n",
    "What are the 20 most common outcomes? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[((12,), 0.03824220182706657),\n",
       " ((11,), 0.0380992150215239),\n",
       " ((13,), 0.038032667992797725),\n",
       " ((10,), 0.037618411457469664),\n",
       " ((14,), 0.03746512036620402),\n",
       " ((9,), 0.036822601595588304),\n",
       " ((15,), 0.036544033638847624),\n",
       " ((8,), 0.035741340182918115),\n",
       " ((16,), 0.035284184613703425),\n",
       " ((7,), 0.03440940023374102),\n",
       " ((17,), 0.03371050842173721),\n",
       " ((6,), 0.03286517629527088),\n",
       " ((18,), 0.031857448871758426),\n",
       " ((5,), 0.031149102741286083),\n",
       " ((19,), 0.029767807751056283),\n",
       " ((4,), 0.029302161098148583),\n",
       " ((20,), 0.027491133463900305),\n",
       " ((3,), 0.0273645356924103),\n",
       " ((1, 5, 1), 0.026621109937678585),\n",
       " ((1, 1), 0.025661022694069335)]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "campaign_probdist(start).most_common(20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The most probable outcome is that the attackers win with 12 remaining armies. The top 10 outcomes have anywhere from 7 to 16 attackers remaining. You have to go down to the 19th most common outcome to find one where the defenders win."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Analyzing and Visualizing Campaigns\n",
    "\n",
    "Let's try to visualize all the possible outcomes. I'll define the **score** of a campaign as the number of attacker armies in the final territory minus the total number of defenders, minus the number of territories that the defenders hold. This score will be positive when the attackers win and negative when they lose. A score cannot be zero (the closest is that there could be one attacker and one defender left, in which case there can be no more attacks, but the score would be -1, because the defenders have one army and one territory). The function `show` plots a histogram of scores probabilities:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def show(probdist, epsilon=0.0002):\n",
    "    \"\"\"Plot and annotate a probability distribution over states.\"\"\"\n",
    "    states = [s for s in probdist if probdist[s] > epsilon] # Ignore low-probability states\n",
    "    X = [score(s)    for s in states]\n",
    "    Y = [probdist[s] for s in states]\n",
    "    μ = sum(score(s) * probdist[s] for s in probdist)\n",
    "    p = attacker_win_probability(probdist)\n",
    "    plt.figure(figsize=(10, 5))\n",
    "    plt.title(f'Attacker wins {p:.2%}. Average score: {μ:.2f}.')\n",
    "    plt.xlabel('Score (positive when attacker wins)')\n",
    "    plt.ylabel('Probability of score')\n",
    "    plt.bar(X, Y, width=3/4)\n",
    "    \n",
    "def score(state): return A(state) - sum(allD(state)) - len(allD(state))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "show(campaign_probdist(start))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Interesting!** To the right of 0, we see a nice  bell-shaped curve. But there is a decidely non-normal pattern on the left side. There are gaps—scores for which the probability is zero—and there are spikes that rise above the normal curve. \n",
    "\n",
    "What's causing the gaps? We know that a campaign score can never be 0. And in this campaign, no score can be -2, because a -2 can only be achieved with the final state `(1, 2)`:  one attacker and two defenders in a single territory; this campaign has only one defender in the final territory, so `(1, 2)` could never occur. Looking at the plot, we see gaps surrounding groups of bars, where the group sizes, reading left to right, are 1, 1, 3, 1, 2, 3, 5, and 1. These are exactly the number of defenders in the final 8 territories, so the gaps are indicating the impossible scores.\n",
    "\n",
    "What's causing the spikes? To some extent they represent probability mass that has shifted over a place from the impossible states to the neighboring possible states. But the spikes are not quite tall enough to fill in the gaps. I admit I don't understand the exact shape of each spike–do you?\n",
    "\n",
    "In the plot below  all the defenders are in a single territory, and there is no visible gap–the normalish shape is restored. However, there is something going on with odd-versus-even scores. I believe that part of what is happening is that all but the very last few battles will be 3-versus-2 battles, and thus will result in 2 casualties, preserving the parity of the total number of armies. The parity is broken only in the final battles. But I don't think that's the full story—what do you think?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "show(campaign_probdist((146, 100)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The odd-even disparity can be lessened by adding a few territories where there will not be 3-versus-2 battles. The result is a very smooth curve, although not quite normal—it is clearly a bit fatter on the left than the right (the mean is 60 and the probability of 20 is greater than the probability of 100."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAm0AAAFNCAYAAABST1gVAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO3debwkVX338c+XYRk2ISxuwDgooAJGlBFN3FAUUcHRCIohikaD+oQQk6jBPMEkilHzuMWoKAIKuICixlExuCC4BgHBBQQzIoYRFAiLQEQc/D1/1LnSNHfpGW7P3Lrzeb9e9bpVp06dOtXVffvX51SdSlUhSZKkuW29tV0BSZIkzcygTZIkqQcM2iRJknrAoE2SJKkHDNokSZJ6wKBNkiSpBwzapDksyeIklWT9tVyPm5Pcf23WQZLWdQZt0oiSnJXk+iQbDaV/MMnRQ2mXJ3nSmq3h+FTVZlV12WyWmWS7JJ9Ocl2SFUleNrT+gCQ/aAHjN5PsOo6ykuyT5CdJrkry3IH0LZN8J8nmq3FsL2zB9nNWdVutnvaZ+1U7xzcn+cLAuo2SvD3Jle0z/J4kG0xRzmMHypiYKsmzV7UsabYZtEkjSLIYeCxQwDPWamVWQzpz7fP+IeAnwL2ApwP/nOQJAEl2Bj4MvAzYEvgMsGyaFse7U9Y7gAOA/YBjkixo6W8E3lRVN63GsR0KXNf+zro5ej5X2yy2JB/QfmBsVlX7DqQfCSwBdgd2AR4O/P1kBVTV1wbK2AzYH7gZ+I9VLUuadVXl5OQ0wwS8FvgG8DbgswPphwG/AW6j+8f+GeBk4LfAr1raq1vejwM/B24EvgrsNlDOxsBbgZ+29V9vaYvpAsX1W75nA5cDu7flRwHfBG4AvgvsPVDmWcAbWr1/Bew0dEwvAj4zsLwc+NjA8hXAHm2+JrYHPgi8G/gccBNwDvCAti7A24Gr23F8b6KuQ/verJW57UDascDJbf5w4HMD69Zrx7DPbJcFXDaw7ufAPYG9gP9YzffK/dr5fzawErjXwLofAvsPLK8PXAs8fHXOZzuHP2zn4TLgpUN1eTVwFXAl8JKh87gR8Bbgv4FfAO8FNp7imHYCzm7n9Frg1IF1uwFfpAtSfwH83UD572j7vrLNb9TW7Q2sAP62veYT52p/4MJ2/N8Efn8VXvfLgSdNse484KCB5T8Grhix3A8AH5iNspyc7u40b36pSWP2ArrWmg8DT0lyL4CqOral/Ut1v8wPqKrn030RTvzq/5dWxueBnemCgu+07Sa8BdgT+ENgK7ov298OViDJi4A3030x/SDJdnSB09Ftm1cCn0iy7cBmz6cLLDenCwgHnQ08Nsl6Se4DbAA8uu3r/nTB0PemeD2eB/wT8Ht0wd4bWvq+wOPoWiC2BJ4L/M8k22fo78T87gPzw+sG189mWVcneWiSh9K95tfTBRhHTLKvUbwAOK+qPkEXUB0ysO6jdK/dhKcA11bVd1bzfF5NF+jcgy6Ae3uShwMk2Q/4a+BJdEHX44fq+Wa687RHW78d3Y+Tybwe+ALd+d4e+Le2j82BL9G1Qt23lfPlts3/pQtC9wAeShcID7ZI3bsd5/2Aw1q9TwBeCmwNvI+uRXSjtq/3JHnPFPWb8OEk1yT5QjufEyZ7D2yfZIvpCkuyCXAgcOLdLUuaFWs7anRymusT8Bi61rRt2vIlwF8NrP8gcPTQNpczxa/+tn5LulaPLbij5eehk+Rb3PK9ErgY2H5g3d/SWigG0s4ADm3zZwGvm+HYrqDr3jmYrnXq28CD6AKAZQP5hlvajhtY9zTgkjb/ROBHdF/W682w76/TffkvbHW4Dri0rXsQcAtdi8yGwFF0AdVrZrssuqDiLLoWw33ogrXXA7/fXs+vAI9fhffLfwGvaPOvAb47sG4nulaxTdryh4HXzuL5/HfgL9v8CcAbh/Zd7W/aa/KAgfV/APxkinJPau+P7YfSnwdcMMU2PwaeNrD8FODyNr83Xev0woH1xwCvHyrj0lFfe7ofHBsDm7TX/efAlm3d0XQtlNvSBYvntNfiPjOU+Xy6bvcMpK1WWU5OszHZ0ibN7FDgC1V1bVv+CKt4rVKSBUnelOTHSX5JF9QBbNOmhXRfclN5FfDuqloxkHY/4KAkN0xMdAHmfQbyXDFD1c6m+wJ9XJs/i65F5vFteSo/H5j/X7pWOarqTOBddN2nv0hybJJ7TFHGIcCOrY7H0AUwK1o5l9C9xu+i697bhi5oXTFpSXejrKq6sKr2rqpHtvQ/Bf4ZOI6uNfFFwMlJBltXJpXk0a0ep7SkjwAPSbJH29dyuta3A1orzjNaHliN85nkqUn+s92AcQNdAL1NW33fofyD89vSBTfnD+zrP1r6ZF5NF+h9O8lFSf60pe/A1O/b+3Ln1t2ftrQJ11TVrQPL9wP+Zuj4dxjaZkpV9Y2q+lVV/W9VvZGui/WxbfUbgAvoul6/SRfc/oaupXI6hwInVVUNpK1uWdLdZtAmTSPJxsBzgMcn+XmSnwN/BUx0p0H3K3vYcNofA0vpuqq2oGtBg+6L8FrgVuAB01RlX+DvJ+5ga66ga5nZcmDatKreNE09hk0EbY9t82czWtA2pap6Z1XtSXet0y50Aedk+X5aVftX1bYtYNqarqVvYv1pVbV7VW0N/APdl/q5Yy7r7cDfV9WvgIfQdXNeTtd1PFVAM+hQunN6YXuvnNPSXzCQZ6KLdClwcQvkYBXPZ+s2/ARd1/q9qmpL4HTu6Lq7iq4rc8IOA/PX0rXu7jawry2qu/D+Lqrq51X1Z1V1X7ruy/ck2anVear37ZV0r/OERS3tLscycPxvGDr+Tarqo1OUP5OivRYtmDu8qrarqvvTddmfX1W3T7Vxkh3oPhsn3anQ1ShLmi0GbdL0ngncDuxK1422B/Bg4Gvc8UX8C2B4DLPhtM2BX9P9g9+EriUHgKr6LV1X1tuS3Le1yv1B7jy0yEV0dze+O8nE3asfomuxeUrbZmGSvZMMflHP5GzgCXQXoK9ox7UfXdBzwSqUA0CSRyR5ZBsC4Ra6YHTSL7MkD06yeZINk/wJXWD6toH1e7bj2pbu+qbPtFazsZSV5Ml03XWfbUk/AZ6YZDe6i+onuzZvcPuFdAH+YdzxXtkD+AvgkIE7JE9p9Xs5d7Sywaqfzw1bva4BViZ5ait3wseAF7XXZhMGrldr77n3010Dd89W/+2SPGWKYztooB7X0wVEtwOfBe6d5BXphsLYPMkjW76P0v3Q2DbJNm3/H5rq9Wv1eVl7/yTJpkmenhGGXEmyKMmj2/lfmORVdC2O3xg4tvu2ch9F10X+DzMU+3zgm1V1p5bE1SxLmh1ru3/WyWkuT3RdRm+dJP05dF2E69PdXDBxx9u/t/VL6W5GuIHuerTNgE/TXc/0U7qAb/A6sY3pLn7/GXfcXTrZ3aNL6ALCp7blR9IFXtfRfXl/DljU1p0FvGSEY7yKu94d9/mhPMPXtB09sG5vYEWb34fu5oWb6VpzPgxsNsV+X9HqfAvdNWlLhtZ/vb1e19EFWpsOrDsEuGg2ymrrN2rn8H4DafvQdWNfBRw8kH4z8NhJjufglneDofSF7bUYvGv0y3R3lt57KO8qnU/gz9v74Qa6u5ZPGTo3E9d2XUkXJBaww0C9/pnurtNf0nXbHjHFufoXuvfmzXTdoYcNrNu9Hc/1bV9HDpT/zvaaXNXmFw6/Z4b2sx9dC+gNbZuPA5u3de8F3jtF/XZr77tb6ILrLw++B+i6/y+n68q/FDhkaPvP0+56HUi7BHjxJPta5bKcnGZrStVMvSeSpL5L8mDgB3TDbqxc2/WRtOrsHpWkeSrJs1qX4e/RDfHxGQM2qb8M2iRp/nopXTfrj+muQXv52q2OpLtjrEFbkv2SXJpkeZIjJ1m/UZJT2/pz0j0qiCR7JbmwTd9N8qxRy5Qkdapqv+ruCt2qqp5VVVet7TpJWn1ju6Yt3fP7fgQ8mW48pHOB51XVxQN5/g/dY0peluRg4FlV9dx2p9NtVbUy3Ujt36Ubq6dmKlOSJGk+GmdL217A8qq6rKpuo7uraelQnqXc8XiQ04B9kqS6wREnrrtYyB3j+YxSpiRJ0ryz/sxZVtt23HkE7hV0t7NPmqe1qt1INz7UtW2snxPoBmd8fls/Spl3sc0229TixYtX9zgkSZLWmPPPP//aqrrLgN7jDNome+TLcF/slHmq6hxgt3ab+olJPj9imV3ByWF0g1yyaNEizjvvvFHrLUmStNYk+elk6ePsHl3BnR+bsj13foTJnfK00cK3oBtU8neq6od0AybuPmKZE9sdW1VLqmrJttuO8vQZSZKkuWucQdu5wM5JdkyyId1o4cuG8izjjgdvHwicWVXVtlkfIMn9gAfSjUA9SpmSJEnzzti6R9s1aIcDZwALgBOq6qIkr6N7CPMy4Hjg5CTL6VrYDm6bPwY4MslvgN8C/6eqrgWYrMxxHYMkSdJcsU48xmrJkiXlNW2SJKkPkpxfVUuG030igiRJUg8YtEmSJPWAQZskSVIPGLRJkiT1gEGbJElSDxi0SZIk9YBBmyRJUg+M89mjkqQ1ZPGRn7vT8uVvevpaqomkcTFok6Q5arJAbDhtIl3S/GfQJknzmC1w0vzhNW2SJEk9YEubJK2DbIGT+segTZLWMgMoSaOwe1SSJKkHDNokSZJ6wO5RSVpD5no3qMOJSHObLW2SJEk9YNAmSZLUAwZtkiRJPWDQJkmS1APeiCBJmpY3KEhzg0GbJM0ygxxJ42D3qCRJUg8YtEmSJPWAQZskSVIPGLRJkiT1gDciSNJq8oYDSWuSQZskabXM9WepSvON3aOSJEk9YNAmSZLUAwZtkiRJPWDQJkmS1AMGbZIkST1g0CZJktQDDvkhSSNweIvR+VpJ42FLmyRJUg+MNWhLsl+SS5MsT3LkJOs3SnJqW39OksUt/clJzk/y/fb3iQPbnNXKvLBN9xznMUiSJM0FY+seTbIAeDfwZGAFcG6SZVV18UC2FwPXV9VOSQ4G3gw8F7gWOKCqrkyyO3AGsN3AdodU1XnjqrskSdJcM86Wtr2A5VV1WVXdBpwCLB3KsxQ4sc2fBuyTJFV1QVVd2dIvAhYm2WiMdZUkSZrTxhm0bQdcMbC8gju3lt0pT1WtBG4Eth7K82zggqr69UDaB1rX6FFJMrvVliRJmnvGGbRNFkzVquRJshtdl+lLB9YfUlUPAR7bpudPuvPksCTnJTnvmmuuWaWKS5IkzTXjHPJjBbDDwPL2wJVT5FmRZH1gC+A6gCTbA58CXlBVP57YoKp+1v7elOQjdN2wJw3vvKqOBY4FWLJkyXCwKEmTcrgKSXPVOFvazgV2TrJjkg2Bg4FlQ3mWAYe2+QOBM6uqkmwJfA54TVV9YyJzkvWTbNPmNwD2B34wxmOQJEmaE8bW0lZVK5McTnfn5wLghKq6KMnrgPOqahlwPHBykuV0LWwHt80PB3YCjkpyVEvbF7gFOKMFbAuALwHvH9cxSJJmj62Y0t0z1iciVNXpwOlDaa8dmL8VOGiS7Y4Gjp6i2D1ns46SJEl94BMRJEmSesCgTZIkqQcM2iRJknrAoE2SJKkHDNokSZJ6YKx3j0rSXOXwE5L6xpY2SZKkHrClTZK01gy3eIKtntJUbGmTJEnqAYM2SZKkHjBokyRJ6gGDNkmSpB4waJMkSeoBgzZJkqQecMgPSfOaQ0pImi9saZMkSeoBgzZJkqQeMGiTJEnqAa9pkyTNOcPXInodomRLmyRJUi8YtEmSJPWAQZskSVIPGLRJkiT1gEGbJElSD3j3qKR5wzsOJc1ntrRJkiT1gEGbJElSDxi0SZIk9YBBmyRJUg94I4IkqTe82UTrMlvaJEmSesCgTZIkqQcM2iRJknrAa9ok9Y7XNUlaF9nSJkmS1AMGbZIkST0w1qAtyX5JLk2yPMmRk6zfKMmpbf05SRa39CcnOT/J99vfJw5ss2dLX57knUkyzmOQJEmaC8YWtCVZALwbeCqwK/C8JLsOZXsxcH1V7QS8HXhzS78WOKCqHgIcCpw8sM0xwGHAzm3ab1zHIEmSNFeMFLQleUySF7X5bZPsOMJmewHLq+qyqroNOAVYOpRnKXBimz8N2CdJquqCqrqypV8ELGytcvcB7lFV36qqAk4CnjnKMUiSJPXZjEFbkn8A/hZ4TUvaAPjQCGVvB1wxsLyipU2ap6pWAjcCWw/leTZwQVX9uuVfMUOZkiRJ884oQ348C3gY8B2AqroyyeYjbDfZtWa1KnmS7EbXZbrvKpQ5se1hdN2oLFq0aKa6SpIkzWmjBG23VVUlKYAkm45Y9gpgh4Hl7YErp8izIsn6wBbAdW0/2wOfAl5QVT8eyL/9DGUCUFXHAscCLFmyZNLATpI0Pzh2n9YFo1zT9rEk7wO2TPJnwJeA94+w3bnAzkl2TLIhcDCwbCjPMrobDQAOBM5sAeKWwOeA11TVNyYyV9VVwE1JHtXuGn0B8OkR6iJJktRrM7a0VdVbkjwZ+CXwQOC1VfXFEbZbmeRw4AxgAXBCVV2U5HXAeVW1DDgeODnJcroWtoPb5ocDOwFHJTmqpe1bVVcDLwc+CGwMfL5NkiRJ89q0QVsbtuOMqnoSMGOgNqyqTgdOH0p77cD8rcBBk2x3NHD0FGWeB+y+qnWR1D92eUnSHabtHq2q24H/TbLFGqqPJEmSJjHKjQi3At9P8kXglonEqjpibLWSJEnSnYwStH2uTZIkSVpLRrkR4cR29+cuLenSqvrNeKslSZKkQTMGbUn2pnvU1OV0g9vukOTQqvrqeKsmSZKkCaN0j76VbriNSwGS7AJ8FNhznBWTJEnSHUYZXHeDiYANoKp+RPf8UUmSJK0ho7S0nZfkeODktnwIcP74qiRJ0t03PM4fONaf+m2UoO3lwJ8DR9Bd0/ZV4D3jrJQkSZLubJSgbX3gX6vqbfC7pyRsNNZaSVqn2CIiSTMb5Zq2L9M953PCxnQPjZckSdIaMkrQtrCqbp5YaPObjK9KkiRJGjZK0HZLkodPLCTZE/jV+KokSZKkYaNc0/YK4ONJrmzL9wGeO74qSZIkadgoj7E6N8mDgAfS3T16iY+xkiRJWrNm7B5NchDddW0/AJYCpw52l0qSJGn8Rrmm7aiquinJY4Cn0D2H9JjxVkuSJEmDRgnabm9/nw4cU1WfBjYcX5UkSZI0bJSg7WdJ3gc8Bzg9yUYjbidJkqRZMkrw9RzgDGC/qroB2Ap41VhrJUmSpDsZ5e7R/wU+ObB8FXDVOCslaX7ycVWaC3wfqq/s5pQkSeqBKYO2du2aJEmS5oDpWtq+BZDk5DVUF0mSJE1humvaNkxyKPCHSf5oeGVVfXKSbSRJkjQG0wVtLwMOAbYEDhhaVwzcnCBJkqTxmjJoq6qvA19Pcl5VHb8G6yRJkqQhMw75AZyc5AjgcW35bOC9PjRekiRpzRklaHsPsEH7C/B8umePvmRclZIkSdKdjRK0PaKqHjqwfGaS746rQpLmh+EBTB28VJLunpEeGJ/kARMLSe7PHQ+RlyRJ0howSkvbq4CvJLkMCHA/4EVjrZUkSZLuZJRnj345yc7AA+mCtkuq6tdjr5kkSWuQXfqa60ZpaaMFad8bc10kSZI0BR8YL0mS1AMGbZIkST0wY9CW5BNJnp5klQO8JPsluTTJ8iRHTrJ+oySntvXnJFnc0rdO8pUkNyd519A2Z7UyL2zTPVe1XpIkSX0zSiB2DPDHwH8leVOSB41ScJIFwLuBpwK7As9LsutQthcD11fVTsDbgTe39FuBo4BXTlH8IVW1R5uuHqU+kiRJfTZj0FZVX6qqQ4CHA5cDX0zyzSQvSrLBNJvuBSyvqsuq6jbgFGDpUJ6lwIlt/jRgnySpqlvas09vXcXjkSRJmpdG6vJMsjXwQrpHV10A/CtdEPfFaTbbDrhiYHlFS5s0T1WtBG4Eth6hSh9oXaNHJckoxyBJktRnMw75keSTwIOAk4EDquqqturUJOdNt+kkabUaeYYdUlU/S7I58Am6Z6GeNEm9DwMOA1i0aNEMRUpaXY5tJUlrxigtbcdV1a5V9caJgC3JRgBVtWSa7VYAOwwsbw9cOVWeJOsDWwDXTVeZqvpZ+3sT8BG6btjJ8h1bVUuqasm22247XZGSJElz3ihB29GTpH1rhO3OBXZOsmOSDYGDgWVDeZYBh7b5A4Ezq2rKlrYk6yfZps1vAOwP/GCEukiSJPXalN2jSe5Nd83Zxkkexh1dmfcANpmp4KpameRw4AxgAXBCVV2U5HXAeVW1DDgeODnJcroWtoMH9n9529eGSZ4J7Av8FDijBWwLgC8B71+1Q5YkSeqf6a5pewrdzQfbA28bSL8J+LtRCq+q04HTh9JeOzB/K3DQFNsunqLYPUfZtyRJ0nwyZdBWVScCJyZ5dlV9Yg3WSZKkOcObbTRXTNc9+idV9SFgcZK/Hl5fVW+bZDNJkiSNwXTdo5u2v5utiYpIkiRpatN1j76v/f2nNVcdSZIkTWa67tF3TrdhVR0x+9WRJEnSZKbrHj1/jdVC0pznxdiStHbNdPeoJEmS5oDpukffUVWvSPIZJnkeaFU9Y6w1kyRJ0u9M1z16cvv7ljVREUmSJE1tuu7R89vfs9uzQx9E1+J2aVXdtobqJ0mSJKZvaQMgydOB9wI/pnv+6I5JXlpVnx935SRJktSZMWgD3go8oaqWAyR5APA5wKBNkrTO8o5qrWnrjZDn6omArbkMuHpM9ZEkSdIkprt79I/a7EVJTgc+RndN20HAuWugbpIkSWqm6x49YGD+F8Dj2/w1wO+NrUaSJEm6i+nuHn3RmqyIpLlh+Dod8FodSZoLRrl7dCHwYmA3YOFEelX96RjrJUmSpAGj3IhwMnBv4CnA2cD2wE3jrJQkSZLubJSgbaeqOgq4pT2P9OnAQ8ZbLUmSJA0aJWj7Tft7Q5LdgS2AxWOrkSRJku5ilMF1j03ye8BRwDJgszYvSZKkNWTGoK2qjmuzZwP3H291JEmSNJkZu0eTbJ3k35J8J8n5Sd6RZOs1UTlJkiR1RukePQX4KvDstnwIcCrwpHFVSpKkPnKcQ43TKEHbVlX1+oHlo5M8c1wVkrRm+OUiSf0yyt2jX0lycJL12vQc4K7/7SVJkjQ20z0w/ia6B8QH+GvgQ23VesDNwD+MvXaSJEkCpn/26OZrsiKSJEma2ijXtJHkGcDj2uJZVfXZ8VVJkiRJw0YZ8uNNwF8CF7fpL1uaJEmS1pBRWtqeBuxRVb8FSHIicAFw5DgrJkmSpDuMcvcowJYD81uMoyKSJEma2igtbW8ELkjyFbo7SR8HvGastZIkSdKdTBu0JQnwdeBRwCPogra/raqfr4G6SZolwwPpOoiuJPXPtEFbVVWSf6+qPYFla6hOkiTNK/5w0mwY5Zq2/0zyiLHXRJIkSVMa5Zq2JwAvS3I5cAtdF2lV1e+Ps2KSJEm6wygtbU8F7g88ETgA2L/9nVGS/ZJcmmR5krsMEZJkoySntvXnJFnc0rdO8pUkNyd519A2eyb5ftvmne26O0mSpHltyqAtycIkrwBeBewH/KyqfjoxzVRwkgXAu+mCvl2B5yXZdSjbi4Hrq2on4O3Am1v6rcBRwCsnKfoY4DBg5zbtN1NdJEmS+m66lrYTgSXA9+kCr7euYtl7Acur6rKqug04BVg6lGdp2w/AacA+SVJVt1TV1+mCt99Jch/gHlX1raoq4CTgmatYL0mSpN6Z7pq2XavqIQBJjge+vYplbwdcMbC8AnjkVHmqamWSG4GtgWunKXPFUJnbTZYxyWF0LXIsWrRoFasuSZI0t0wXtP1mYqYFVKta9mQb1GrkWa38VXUscCzAkiVLpitTmjccVkCS5q/pgraHJvllmw+wcVueuHv0HjOUvQLYYWB5e+DKKfKsSLI+3SOyrpuhzO1nKFOSJGnemfKatqpaUFX3aNPmVbX+wPxMARvAucDOSXZMsiFwMHcdoHcZcGibPxA4s12rNlWdrgJuSvKodtfoC4BPj1AXSZKkXhtlnLbV0rpUDwfOABYAJ1TVRUleB5xXVcuA44GTkyyna2E7eGL7Ni7cPYANkzwT2LeqLgZeDnwQ2Bj4fJskSZLmtbEFbQBVdTpw+lDaawfmbwUOmmLbxVOknwfsPnu1lCRp7fA6VK2KUQbXlSRJ0lpm0CZJktQDBm2SJEk9MNZr2iSNh9fBSNK6x5Y2SZKkHjBokyRJ6gGDNkmSpB4waJMkSeoBgzZJkqQe8O5RSZLmGO8Q12RsaZMkSeoBW9qkOWz41zb4i1uS1lW2tEmSJPWAQZskSVIPGLRJkiT1gEGbJElSDxi0SZIk9YBBmyRJUg845Ic0RziYpiRpOgZtkiT1hD/u1m12j0qSJPWAQZskSVIPGLRJkiT1gEGbJElSDxi0SZIk9YB3j0prmHd/SZJWhy1tkiRJPWBLmyRJPTbceg+24M9XtrRJkiT1gEGbJElSDxi0SZIk9YDXtElj4l2ikqTZZEubJElSDxi0SZIk9YBBmyRJUg8YtEmSJPXAWG9ESLIf8K/AAuC4qnrT0PqNgJOAPYH/AZ5bVZe3da8BXgzcDhxRVWe09MuBm1r6yqpaMs5jkCSpj7wZav4ZW9CWZAHwbuDJwArg3CTLqurigWwvBq6vqp2SHAy8GXhukl2Bg4HdgPsCX0qyS1Xd3rZ7QlVdO666S6vC0cglSWvCOLtH9wKWV9VlVXUbcAqwdCjPUuDENn8asE+StPRTqurXVfUTYHkrT5IkaZ00zqBtO+CKgeUVLW3SPFW1ErgR2HqGbQv4QpLzkxw2hnpLkiTNOeO8pi2TpNWIeabb9tFVdWWSewJfTHJJVX31LjvvArrDABYtWjR6rSVJkuagcba0rQB2GFjeHrhyqjxJ1ge2AK6bbtuqmvh7NfAppug2rapjq2pJVS3Zdttt7/bBSJIkrU3jbGk7F9g5yY7Az+huLPjjoTzLgEOBbwEHAmdWVSVZBnwkydvobkTYGfh2kk2B9arqpja/L/C6MR6D9DvecCBJWpvGFrRV1cokhwNn0A35cUJVXZTkdcB5VbUMOB44Oclyuha2g9u2F+UVL0EAAA5GSURBVCX5GHAxsBL486q6Pcm9gE919yqwPvCRqvqPcR2DJEnzjUOB9NdYx2mrqtOB04fSXjswfytw0BTbvgF4w1DaZcBDZ7+mkiRJc5tPRJAkSeoBgzZJkqQeGGv3qNRXXvMhSZprbGmTJEnqAVvaJEmSPQw9YEubJElSD9jSpnWavywlSX1hS5skSVIPGLRJkiT1gEGbJElSD3hNm9YJXrsmSatu+H8n+P9zbbKlTZIkqQcM2iRJknrAoE2SJKkHvKZN84rXX0iS5iuDNkmStEr8gbx22D0qSZLUA7a0qbccxkOStC6xpU2SJKkHbGmTJEmzwh6Q8TJo05znPwFJkuwelSRJ6gVb2jRn2KImSdLUDNokSdJY+aN8dtg9KkmS1AO2tGmNcyRtSZJWnUGbJElaK+w2XTUGbRobW9QkSZo9Bm2aFf5akiRpvAzaJEnSnGEvzdQM2rRKbFGTJGntMGjTpAzOJElzid9LjtMmSZLUC7a0reO8dkCS1GfrUgucQds8NNUbeF16Y0uSNN8YtPWYQZgkSZObj9+RYw3akuwH/CuwADiuqt40tH4j4CRgT+B/gOdW1eVt3WuAFwO3A0dU1RmjlDkf2YUpSdLd1/fv07EFbUkWAO8GngysAM5NsqyqLh7I9mLg+qraKcnBwJuB5ybZFTgY2A24L/ClJLu0bWYqsxcm+wXQ9zeTJEl91Jfv33G2tO0FLK+qywCSnAIsBQYDrKXAP7b504B3JUlLP6Wqfg38JMnyVh4jlLlWeB2ZJEnzy1z7Dh/nkB/bAVcMLK9oaZPmqaqVwI3A1tNsO0qZkiRJ806qajwFJwcBT6mql7Tl5wN7VdVfDOS5qOVZ0ZZ/TNei9jrgW1X1oZZ+PHA6XZA5bZkDZR8GHNYWHwhcOpYDnT+2Aa5d25XQrPF8zi+ez/nDczm/jOt83q+qth1OHGf36Apgh4Hl7YErp8izIsn6wBbAdTNsO1OZAFTVscCxq1v5dU2S86pqydquh2aH53N+8XzOH57L+WVNn89xdo+eC+ycZMckG9LdWLBsKM8y4NA2fyBwZnVNf8uAg5NslGRHYGfg2yOWKUmSNO+MraWtqlYmORw4g254jhOq6qIkrwPOq6plwPHAye1Gg+vogjBavo/R3WCwEvjzqrodYLIyx3UMkiRJc8XYrmlTvyQ5rHUpax7wfM4vns/5w3M5v6zp82nQJkmS1APjvKZNkiRJs8SgbR2UZIckX0nywyQXJfnLlr5Vki8m+a/29/fWdl01miQLklyQ5LNtecck57RzeWq7cUc9kGTLJKcluaR9Rv/Az2Z/Jfmr9n/2B0k+mmShn8/+SHJCkquT/GAgbdLPYzrvTLI8yfeSPHy262PQtm5aCfxNVT0YeBTw5+3RYUcCX66qnYEvt2X1w18CPxxYfjPw9nYur6d7ZJz64V+B/6iqBwEPpTuvfjZ7KMl2wBHAkqrane4GuolHNvr57IcPAvsNpU31eXwq3WgXO9ONE3vMbFfGoG0dVFVXVdV32vxNdF8K29E9EuzElu1E4Jlrp4ZaFUm2B54OHNeWAzyR7tFw4LnsjST3AB5Hd2c9VXVbVd2An80+Wx/YuI1FuglwFX4+e6Oqvko3usWgqT6PS4GTqvOfwJZJ7jOb9TFoW8clWQw8DDgHuFdVXQVdYAfcc+3VTKvgHcCrgd+25a2BG9qj4cDHvfXJ/YFrgA+07u7jkmyKn81eqqqfAW8B/psuWLsROB8/n3031edx7I/aNGhbhyXZDPgE8Iqq+uXaro9WXZL9gaur6vzB5Emyept4P6wPPBw4pqoeBtyCXaG91a51WgrsCNwX2JSuC22Yn8/5Yez/ew3a1lFJNqAL2D5cVZ9syb+YaMptf69eW/XTyB4NPCPJ5cApdN0u76Brlp8YPHvKx71pzlkBrKiqc9ryaXRBnJ/NfnoS8JOquqaqfgN8EvhD/Hz23VSfx1Ee33m3GLStg9o1T8cDP6yqtw2sGnys2KHAp9d03bRqquo1VbV9VS2mu8D5zKo6BPgK3aPhwHPZG1X1c+CKJA9sSfvQPRnGz2Y//TfwqCSbtP+7E+fTz2e/TfV5XAa8oN1F+ijgxolu1Nni4LrroCSPAb4GfJ87roP6O7rr2j4GLKL7Z3NQVQ1fgKk5KsnewCurav8k96dredsKuAD4k6r69dqsn0aTZA+6m0o2BC4DXkT3A9vPZg8l+SfguXR37V8AvITuOic/nz2Q5KPA3sA2wC+AfwD+nUk+jy0wfxfd3ab/C7yoqs6b1foYtEmSJM19do9KkiT1gEGbJElSDxi0SZIk9YBBmyRJUg8YtEmSJPWAQZs0TyX5v0kuSvK9JBcmeeQa3HeSnNmepTlbZb4syQva/AuT3Hdg3XFJdp2tfU1Th7OSLBn3fgb298zB4xo+7lUsa+8kn5292s24v9OTbLka2+3fhsmQNMSgTZqHkvwBsD/w8Kr6fbqR2a+YfqsZy1x/5ly/8zTgu7P5eLSqem9VndQWX0j3WKCJdS+pqotna19zyDOBwWD0hQwc95qyiucegKp6WnvY/ar6HN1TPjZZjW2lec2gTZqf7gNcOzFgZ1VdW1VXAiR5RJJvJvlukm8n2TzJwiQfSPL99qDyJ7S8L0zy8SSfAb7Q0l6V5NzWgjdVi8ghtFHCkyxOckmSE9s2p018ISfZp+3v+0lOSLJRS39Tkotb/re0tH9M8sokBwJLgA+3FsSNJ1rAkrw8yb9MVKLV/9/a/J+0470wyfuSLBiscJK9knyyzS9N8qskG7bX5rKBrAe1cn6U5LEt/4Ik/2/gdXlpS9+71e209hp8uA3AydC+/6xt+90kn2gj6P8h8Azg/7U6/+0kx/3att0Pkhw7UXaSnZJ8qZX3nSQPGNrfI9rrfv8km7bX/tyWtnSqcz+w/auTHNHm357kzIHz+aE2f3mSbdr5/2GS96dr+f1Cko1bniMGzvMp7b1awFl0PzokDaoqJyeneTYBmwEXAj8C3gM8vqVPjLL/iLZ8D7qHlP8N8IGW9iC6Ub4X0rXsrAC2auv2BY6lezDyesBngcdNsv+fApu3+cV0D01+dFs+AXhlK/8KYJeWfhLwCrpR4i/ljsG/t2x//5HuiQ/QfakvGdjfWXQBzbbA8oH0zwOPAR4MfAbYoKW/B3jBUJ3Xp3tOJMBbgHPpnu36eOCjA/t5a5t/GvClNn8Y8PdtfiPgPLqHhO8N3Ej3DML1gG8Bj5nk9dp6YP5o4C/a/AeBA4ePc2B5q4H5k4ED2vw5wLPa/EJgk1aXz9I9+/J8YFFb/890I/IDbEn3ntl0+NwP1fdRwMfb/NeAbwMb0I0W/9KWfjndKPKL6Z4GsEdL/9jA/q4ENho8z23+EODf1vbnyMlprk22tEnzUFXdDOxJF0xcA5ya5IXAA4Grqurclu+XVbWSLrA5uaVdQhd07dKK+2Ld8cikfdt0AfAdugBv50mqsFVV3TSwfEVVfaPNf6jt74F0QdKPWvqJwOOAXwK3Ascl+SO6x8GMetzXAJcleVSSrds+vkH3zMc9gXOTXNiW7z+07UpgeZIHA3sBb2v1eSxdYDLhk+3v+XQBCXSvyQta2ecAW3PH6/LtqlpRVb+lC6QXc1e7J/laku/TBSy7jXjIT0hyTtvuicBuSTYHtquqT7XjurWqJl7DB9MF3QdU1X8P1P3IVvez6IK8RW3d4LkfdD6wZ9vXr+mC0SXc9bWa8JOqunBg28Vt/nt0LYd/QhfYTbiatdANLM11q3ydgqR+qKrb6b6Ez2pf6ofSBVqTPbvuLl12A24ZyvfGqnrfDLtfmWS9FqgwyT5rqn1W1coke9EFVgcDh9MFJKM6FXgOcAnwqaqq1m14YlW9ZoZtvwY8FfgN8CW6lq4FdC2DEyaeEXk7d/wPDV3r2BmDhaV7HuzgMyUHtxn0QeCZVfXdFlzvPUM9SbKQrsVwSVVdkeQf6QKu6c7lVS3Pw+hauSbq/uyqunSo/Edy53P/O1X1mySX0z0X9Zt0wdcTgAcAP5xkk+HXYOM2/3S6wPgZwFFJdmvB80LgV9Mch7ROsqVNmoeSPDDJYAvYHnStZ5cA903yiJZv83QXmX+VroWHJLvQtbRcyl2dAfxpks1a3u2S3HOSfJdy55asRelujgB4HvD1VpfFSXZq6c8Hzm5lb1FVp9N1l+4xSfk3AZtPcfifpLuA/3l0ARzAl4EDJ+qaZKsk95tk26+2fX6rtdptTdeaeNEU+5pwBvDyJBu08ndJsukM2wzaHLiqbX/IQPrwcQ4uL2x/r22v2YHQtZ4CK5I8s9Vlo9xxUf8NdIHSP7eAcqLufzFwPdzDRqzzV+mC2a/SBbsvAy6sqpEeaJ1kPWCHqvoK8Gq6rtnN2updgB+MWA9pnWHQJs1PmwEnTlzkTXcH4j9W1W3Ac4F/S/Jd4It0X/7vARa0FrlTgRdWu4lhUFV9AfgI8K2W9zQmD54+x51bi34IHNrqshVwTFXdStdS8/FW1m+B97byPtvyng381STlfxB478QF+UN1vB64GLhfVX27pV0M/D3whVbuF+lu1hh2DnAvukAEuhak740QiBzX9vmdJD8A3seq9WQc1fb9RbpgdsIpwKvaDQIPYOC46Vqv3g98H/h3umvwJjwfOKId6zeBe0+sqKpfAAcA726taa+nux7te63urx+xzl+jew2/1cq8lcm7RqeyAPhQO/cXAG+vO+42fQLde0jSgIz4o0iSRpbkPsBJVfXkJIuBz1bV7mu3VuqDJPcCPlJV+6ztukhzjS1tkmZdVV0FvD+zOLiu1hmL6O5mljTEljZJkqQesKVNkiSpBwzaJEmSesCgTZIkqQcM2iRJknrAoE2SJKkHDNokSZJ64P8DkbSirKpTL44AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "show(campaign_probdist((146, 93, 1, 1, 1, 1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Analyzing Single-Territory Attacks\n",
    "\n",
    "I want to analyze a simpler situation: With *A* attackers and *D* defenders in a single territory, what is the probability the attackers win?  \n",
    "\n",
    "I will make a chart with the number of defenders varying from 1 to 60, and with the number of attackers separated into eight cases (depicted as eight lines), where in each case there are Δ more attackers than defenders:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "def chart(defenders=range(1, 61), deltas=(9, 5, 2, 1, 0, -1, -2, -5)):\n",
    "    \"\"\"Plot win probability for various numbers of defenders and Δ more attackers.\"\"\"\n",
    "    plt.figure(figsize=(10, 5)); plt.grid()\n",
    "    plt.title('Each line: attackers with Δ more armies than defenders')\n",
    "    plt.xlabel('Number of Defenders'); plt.ylabel('Win Probability for Attackers')\n",
    "    plt.yticks([i / 10 for i in range(11)]); plt.xticks(range(0, 61, 5))\n",
    "    for delta in deltas:\n",
    "        winprobs = [attacker_win_probability(campaign_probdist((max(0, d + delta), d))) \n",
    "                    for d in defenders]\n",
    "        plt.plot(defenders, winprobs, 'o-', label=f'Δ = {delta:2}')\n",
    "    plt.legend(shadow=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmEAAAFNCAYAAABIc7ibAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nOydd3hU1daH351eSQiQkASU3kERBBsCIl3s136v5do/G3Y6FhB799p7QUREmoJKrwLSe28hhIR0Uqbs749zJkxmzjkzIZkkwH6fJ09mzl6zZ53+m7XW3kdIKVEoFAqFQqFQVC9BNe2AQqFQKBQKxZmIEmEKhUKhUCgUNYASYQqFQqFQKBQ1gBJhCoVCoVAoFDWAEmEKhUKhUCgUNYASYQqFQqFQKBQ1gBJhilMaIcQdQojFFbDfK4S4XH89XAjxaeC8q3mEEL2EEAdr2g8zhBC/CSFut2j/UgjxYnX6dLpSXce7EGK+EOLuQH+PyXeXnd9+2F4jhDgghCgQQnSuYj/UcavwCyXCFNWGfoEs0i96rr/3asofKeV4KWWN3CzcMbppCSGkEKJFTflUXUgpB0opv4KKC2ozhBDR+rE1q/Ienj4E4ngXQowVQnxblX1WI68BD0kpY6SUa2raGcWZSUhNO6A44xgipfyzpp1QVAwhRIiU0l7TfvjJ9cBq4GIhRLKU8nB1OxDo7XWK7Y/aytnAppp2wh21X888VCRMUSsQQjQXQswVQmQJITKFEN8JIeLd2hsLIaYIIY7qNu95fP41IUS2EGKPEGKgn99Z9iteCNFEjz7dLoTYr/swws02SAjxrBBil/79k4QQCX5+T10hxAzd92z9dSO9bRzQA3jPFRkUQizUP7pOX3ajVR96PwlCiC+EEGl6+1QTXx4RQmx2+/4rhBBrhRA5QoilQohObrZ7hRDPCCHWA4VCiBD9/SEhRL4QYpsQoo/BdzTV+wvS338qhMhwa/9WCPGY/nq+EOJuIURb4EPgQn2dc9y6rCuEmKl/5wohRHMfm/x24FNgJnCrlaG+zx8UQuzQ+39BPxaXCSHy9P0c5mZ/jxBipxDimBBimhAixaOv/xNC7AB26MvaCCH+0O23CSFusPDlTiHEFt2P3UKI+9zaegkhDurbPx34wm3Z00KIDCHEYSHE1UKIQUKI7fp3Dnfro1zUSghxgb7Pc4QQ64QQvdza7tB9yNfPKa/tKIQYAAwHbtT32Tq35rOFEEv0z88RQtR3+9xPQoh0IUSuEGKhEKK9W9uXQoj3/d3fQoh/CyH2Ce2cHOHRZnjOCiHChRAFQDDaObZLt08RQvwstHNsjxDiEY9tN0kI8bXu1yYhRFe39s5CiH/0th+BCA9fqvw8U5wmSCnVn/qrlj9gL3C5SVsLoC8QDjQAFgJv6W3BwDrgTSAa7QJ3id52B2AD7tHtHgDSAOHLB2As8K3+ugkggU+ASOAcoARoq7c/BiwHGuk+fgT84NbveuAWk++sB1wHRAGxwE/AVLf2+cDdHp+RQIsK9DET+BGoC4QCPfXlvYCD+utRwD9AA/39eUAG0F3fdrfr2yfcbVutBRrr26Q1cABIcdtmzU3WeT/QRX+9Ddjtti33A509113fl4s9+vkSOAZ0Q4vcfwdMtDjGzgIK9G00BFjv45iUwDSgDtBe3+d/Ac2AOGAzcLtuexmQqW+3cOBdYKFHX38ACfr2ita315267+fpn29v4stgoDkggJ7AceA8t/1oB17WvzvSbdlofZ/fAxwFvtfXvz1QDDQzON5TgSxgENqP8b76+wa633lAa9022cLnsj49juddQCvdz/nABLf2u3T/woG3gLUns7+Bdvq+vlTv6w19e7jOb1/nbNk5pm+D1fq2DNP3/26gv9t6FuvbKxh4CViut4UB+4Ch+n64Hu2a9GKgzzP1d+r/1bgD6u/M+dMvNgVAjtvfPSa2VwNr9NcX6jeXEAO7O4Cdbu+j9ItrQwsfrERYIzfbv4Gb9NdbgD5ubcn6hdbLJz+2w7lAttv7+fgQYVZ96L44gboGdr2AQ/oNajEQ59b2P+AFD/ttnBBwe4G73Npa6DeTy4FQH+v4DfA40FDv8xXgfqCpvt+DPNcdcxH2qdv7QcBWi+8dCUzSX4eiCYvOFvYSuNjt/WrgGbf3r3Pix8BnwCtubTH6MdDEra/L3NpvBBZ5fN9HwBg/j5OpwKNu+7EUiPDYt0VAsP4+Vvehu8f6XG1wvD8DfOPxfbPRBEK0vo+uAyJ9+FjWp8fxPNLt/YPA7yafj9d9jqvo/kYTTBPd3kfr28h1flues5QXYd2B/R79DwO+cFvPP93a2gFF+utL8fjhByzlhAgL2Hmm/k79P5WOVFQ3V0sp493+PgEQQiQKISbqIfg84FvAlcJoDOyT5rUS6a4XUsrj+suYk/Qv3e31cbd+zgZ+0dMJOWgXeAeQ5KtDIUSUEOIjPW2ShxblixdCBPvrlI8+GgPHpJTZJh+PB+4FXpJS5rotPxt4wrVO+no1BlLcbA64Xkgpd6JFF8YCGfr+crd1ZwGaSLhU93U+WnSnJ5owcfq77pjvEyP+gxYJQkppA35GExZWHHF7XWTw3vV9KWgRD/T+C9BEXqqb/QG312cD3T22761owtQLIcRAIcRyPY2YgyZA6ruZHJVSFnt8LEtK6XDz1Wh9jLbX2cC/PHy7BEiWUhaiCcj7gcN6arCNkc8WGO4zIUSwEGKCniLMQxMgUH49/d3fKZQ/PgvR9of7Ovp7zp4NpHhsj+Eetp5+RQghQnQ/DkmpKSidfW6vA3meKU5xlAhT1BZeQvtl2klKWQe4DS0tA9oF6iz9gldTHAAGegjICCnlIT8++wRaiqG7vm6X6std6ycNP+V/HweABOFWQ+dBNnAFWh3RxR7rNM5jnaKklD+42ZTzTUr5vZTyErQbi0RLjxmxAK3WrZf+ejFwMZoIW2DyGX+2gylCiIuAROA3t8XfAzdX0bGThrberu+LRksTux8D7utwAFjgsX1jpJQPGPgejiYYXwOSpJTxwCxOHCOefVeWA2iRMHffoqWUEwCklLOllH3Rokdb0dL0RlTUp1uAq9CiPHFoEWgov57+chhNzGgdCBGFtj9cVOScPQDs8bCNlVIO8tOPVCGE+zqc5dF3oM4zxSmOEmGK2kIseqpSCJEKPOXW9jfahW6C0KYfiPAQE9XBh8A4IcTZAEKIBkKIq/z8bCxaRCJHaMX8Yzzaj6DVoFgtM+1DaqP/fgM+EFoBf6gQ4lL3zqSU89GiML8IIbrriz8B7hdCdBca0UKIwUKIWKOVEEK0FkJcpguGYt0fh5GtlHKH3n4bWt1Unr5O12Euwo4AjYRbIXwFuR2tvkvox0gE2rHjAPwarOGD74E7hRDn6ttgPLBCSrnXxH4G0EpoxeOh+t/5QhuE4EkYWt3SUcAutMEl/arAZzO+BYYIIfrr0akIoRX6NxJCJAkhrtRFZgnaeWm4n9H2WROhD8Lwg1i9zyy00oHxlViHycAVQohL9GPmecrf0ypyzv4N5OkF8ZH6NukghDjfDz+WodWiPaIX1V+LVtPmImDnmeLUR4kwRXUzXZSfJ+wXfflzaAWsuWhF5lNcH9DTLUPQaiX2AwfR0iXVydtoN/g5Qoh8tIJfl5hBaKOlzEbivYVWcJupf+53g76vF9qoxnf0ZWOBr/T0xQ1+9PFvtHqXrWj1JI95OiGl/AOtSHyaEKKLlHIVWjH3e2jRsp1odVlmhAMTdB/S0aJOwy3sF6Cly/a7vReA2ZxMc9GmDEgXQmRa9OuFLrhuQNsORW5/hWjRHF8pSZ9IKf9CG9zwM9qPgubATRb2+WhC6ia0KFo6JwrrjWwfASah7Ytb0I63gCClPIAWkRqOJvwOoP3wCdL/ntB9PoYWvXzQpKuf9P9ZQoh//Pjqr9FSdYfQBj0sP8lVQEq5Cfg/NHF8GG27uU9MbHnOevTlusacC+xBO8Y/RYvW+fKjFLgW7dzJRrs2uV+/An2eKU5hRPk0tkKhUCgUCoWiOlCRMIVCoVAoFIoaQIkwhUKhUCgUihpAiTCFQqFQKBSKGkCJMIVCoVAoFIoaQIkwhUKhUCgUihqgJie/PCnq168vmzRpUqk+CgsLiY6OrhqHAozyNTAoXwOD8jUwKF8Dg/I1MChfy7N69epMKWUDw8aafm5SRf+6dOkiK8u8efMq3Ud1oXwNDMrXwKB8DQzK18CgfA0MytfyAKukenakQqFQKBQKRe1BiTCFQqFQKBSKGkCJMIVCoVAoFIoaQIkwhUKhUCgUihpAiTCFQqFQKBSKGkCJMIVCoVAoFIoaQIkwhUKhUCgUihogYCJMCPG5ECJDCLHRpF0IId4RQuwUQqwXQpwXKF/8ZeqaQ1w8YS5Nn53JxRPmMnXNoZp2SaFQKBQKxWlKICNhXwIDLNoHAi31v3uB/wXQF59MXXOIYVM2cCinCAkcyili2JQNSogpFAqFQqEICAETYVLKhcAxC5OrgK/1CWWXA/FCiORA+eOLV2dvo8jmKLesyObg1dnbyi1T0TKFQqFQKBRVgdBm1A9Q50I0AWZIKTsYtM0AJkgpF+vv/wKekVKuMrC9Fy1aRlJSUpeJEydWyq+CggJiYmLKLbvj90KuDFrM0yGTSBGZpMn6vGK/gWnOS2iTEERKTBAldsmKdAd254nPhQXBHR3CuCgltGzZ0jQbP2+3kVUsqRchuK5VaLn2yvpaW1G+Bgbla2BQvgYG5WtgUL4GhurwtXfv3qullF2N2mryAd7CYJmhIpRSfgx8DNC1a1fZq1evSn3x/Pnz8ezjjsVjeNr2KVGiFIBGIpMJoZ8SLoPYFTOIlRkF5Bc7vPoqdcKPO5z07NaBlkkxLNmRyTd/baTIpq1KVrHkmy0O2rVtx9WdU6vE19qK8jUwKF8Dg/I1MChfA4PyNTDUtK81KcIOAo3d3jcC0mrIF54O/ZEoe2m5ZVGilOeifibqwXFIKWk2bJahSswtsnPrpysAEAI8g4uutKZLhE1dc4hXZ28jLaeIlPhInurf+qQEmkKhUCgUilOXmhRh04CHhBATge5ArpTycE05E1WUbrlcCEFKfCSHcoq8bBrWieD1G85h+5F8npu+2bCfQzlF3PfNKgQwd2sGpQ5ZtnzYlA0A5YSYS6gdyikidflcJdQUCoVCoTjNCOQUFT8Ay4DWQoiDQoj/CiHuF0Lcr5vMAnYDO4FPgAcD5YtfxDXyufyp/q2JDA0u1xwZGsyzA9twcYv63HlxU1LjIw27iQwNYseRAn7fdKRMgLkosjkYM20TK/ceI6/YVm6kJqiRmgqFQqFQnI4ELBImpbzZR7sE/i9Q319h+oyG6Y+AzSPSddEjZS9dkSirVOJT/VszbMqGciMtI0ODeenajlzdOZWmz840SWna+NeHywAIFgKH9BZqKqWpUCgUCsXpQ02mI2sXnW7Q/v/1POQehNiGUJAB+5dB93vLzK7unGopdnwJNbOUZlKdcF66tiNb0/N55fdtXu2gRcQe+HY1Tqdk7rYMbH6mNJVQUygUCoWi9qFEmDudbjghxgDmvwzzx0PnW6HF5X53YyXUzCJlwwa25bI2SVzWJonvlu83FGoRoUFsTc9nT2ahV1uRzcGoqRuRSJo3iGFLWh5jp28u+x4l1BQKhUKhqF2oZ0daccljUK8FzHzSO015klzdOZWXru1IanwkAkiNjyxLVbowqz2bcG0n5j3Zy3BuD4D8EjtDf1zHle8t4RkPoQeaUHvpty3YHdpEZ+opAQqFQqFQ1BwqEmZFSDgMfgO+vhIWvQGXjaiSbiuS0jyUU0SqnynNlLgIvv5vN3ZmFHL/t6sN+z6SV0Lb0b/TOCGKtOwiit1nnkXVnikUCoVCUV0oEeaLZj2h042w+E3o+C9o0KpavtYl1IwmkjNLaT49oA0tEmNpkRhLqolQi48M5ebuZ7HnaCG7j3qnNUGLiN326QocTicr92Zjd7rXnq0v88+Fmk5DoVAoFIqKo0SYP/R7Ebb/DjMfh9unazOy1iCVGaU59sr2ZXYXT5hrKNQiQ4PJL7Gz4WAOTq+JZ508+dM6pq1LIzU+ktzjpfy2Kd1ykIA/0TQVcVMoFArFmYYSYf4QkwiXj4UZQ2H9j3DOTTXtUaVHaYJ/02kYYXdK0nOLWbX3GHnFdq/2IpuDpyevZ+7WDApKbCzakekh0spH01y1aWoQgUKhUCjOJJQI85fz7oC138PsEdCyH0Ql1LRHPgnUdBqp8ZHMerQHgOm8Z6UOJ2sP5LD/2HGvtiKbk8cnreWLpXtJig1nyc5Mw0EEr8zeWiGhpkSaQqFQKE4llAjzl6AguOJN+LAHvNUBSo9rs+n3GV1+WotTjJOZTuOp/q3L3lsJtYVP9zYVaU4JdSJC2Jd1nMJS7wejA6TlFHP+uD9pEBPOrqMFlBgMIhg/awsXNa/Hoh1HGTl1k9/RNLP6NSXkFAqFQlFdKBFWETK2QFAwlOoF7bkHtFn24ZQWYmZUJqXpEmpWIu2b/3YHzGvTYsND6NMmkaP5JWw+nGfoY0Z+Cd3G/2XYVmRzMHLqRjILSqgbFca29Dy+WravTMx5CrWqTIsqMadQKBQKXygRVhH+eh6cHjVQtiJt+WkowqDy02n4E00zs3nh6g4+BxEkRIUytF9rRk3daOhfQYmdF2duMfW/yObgyZ/W8fWyvWxKyzOMtr0wYzON6kYSFxnKsl2ZjP9tK8U2YyEHVZc6VaNOFQqF4vRGibCKkHuwYsvPEKym0/AnmlaZiNvoIdpozw/n7zKJuEUw69FLyTleSq9X5xumRu1OSVRYiJcAc5FVWMr1+nM9jSiyOXjm5/XM3pRObEQIszYcNqxxGzdzCx1S67B4ZyYTqlnIqaidQqFQ1D6UCKsIcY20FKQnQcFwaDWkdql+n04BfEXT/LHxJdTMI25tiIsMJS4y1DI1+u3d3U2jbQ1iwnnthnPIK7Lx8A9rDP0rsTvZkVFAfrGNghLjGrejBSVc/sZCw7Yim4OnJq/jh7/3ExMewtJdWYZCbuz0TYSHBLH2YA5fLNlLqVtq9dkp67E7nFzftTHgv5CrjqidEowKhULhjRJhFaHPaK0GzP0RRsHhEBoJn/aFS5+CS5+E4NCa8/E0xkqoVUX9mln7iMFt6dmqAQATfttqKuT+fLwnYJ46rRcdxtgr25sKOZtDIoH0vGIvAeYi57iNB777x7Ct2ObkycnreXbKBiJDgykstRvM8+Zg2JT1LNqRSURoEL+uPWQo9p6bvomosGD+2Z/N555i7+f1FJTYuaZzKuEhQcxYf9hSyFWlGDydBGN1+apQ1BZOpXOruhBSGiVoai9du3aVq1atqlQfRmkzv1k/SasByz14YnRky37w29PaHGIpnaH9NfD3J+VtTrJmrFK+VjOngq/lTryTOHk9hQCUn1vNHxszkZYaH8mSZy8DzIVcUp1wvryzG4PeXmSYWgV4sFdzimwOvliy13Q7pMZHUmxzkFVYampTWUKCBO1T49iSlkepwzvVGxUWzA1dGxMaLPjh7wMUlHjPORcfFcpzV7YnNDiIkVM3cszA38TYcL6/5wIWbMvgldnbyqWVI0KDGH91B645rxFCCJ/7pir2rz821dWHq59qv6lVsg/l6+nn66l0blU1QojVUsquhm2BFGFCiAHA20Aw8KmUcoJH+9nA50AD4Bhwm5TSssCqxkWYFZumwtQHwebxOKDQSBjyzkkJsVNB2Lg4U3yt7AWtpoWcPzaJseF8fsf5DHl3sanYGz6oDSU2J6//sd10W13aqgELtx81ba8TEYLNIU0jf1VJSJAoewSXJ8FBgqb1o9mbWWhoEx4SxIXN6xESJFi8M7Osns+dqLBgrj0vlZCgIH5afYBCg7R0bEQI9/dszkcLdhlOdBwfGcqwQW0IEoLxs7aQfdzmZZMQHcYr13XimZ/XG4ro+jFhfHhbF4QQLNpxlP/N31VOmIaHBPHo5S25vG0SApi7NYM3/tjuZfPMgNb075DMnE3pvPzb1nLPmY0ICWLkFW0Z1DEFAfy28TDPz9hcbrtEhAbx3JD2XHFOCjPXpzF62iav9hev6sBV+jE/fe0hhk/dWM4mMjSI8ddox3x1ieiT7yOI8Vd35Erd5tc1B73Wx7XOV5yTwvR1aYz61bt9rL7NpJTMWJ/Gc9O9t+vIwe0Y2KEhszYeZtzMLeXbQ4J4dlAb+rdviJQwe1M6E37b6rV/n+zXmj5tE5HAn5uPGB4Dj/RpSa/WDZi7NYP35u70ar+/Z3MubVUfp4SF24/y0cLdZVFzgLDgIO66pAkXNq/P4z+uNTxeE6JDGXd1R5wSRk7dYHjMx0eFMnxQW6SUvDRrKzlF3jZxkSE80qcV7/y1ndwi73OrTkQId/dohlNKPlu8h3yD88/92liV1IgIE0IEA9uBvsBBYCVws5Rys5vNT8AMKeVXQojLgDullP+26rdWizCA19tCfpr38rjGMNR4BJ8VZ4qwqW5q2tdT5VdlVYi9ykb+frjnAmwOyW2freBofomXTUJUKGOubM+jE9d6tbl45LIW2J2SD+bvMrUZ3DGZmRsOm7af0ygOu1OyKc14uhTQBJLDKck1uEkoAkuQwCv97k5wkPa4OYeFka8+FKc3AtgzYXDV92shwoKq/NtO0A3YKaXcLaUsBSYCV3nYtANckzzNM2g/9cg3uYif4SMoFeW5unMqS569jD0TBrPk2csMQ+Aumy8HRHvZXN05lZeu7UhqfCQCTdB4htKrwuap/q2JDA0u55fRFCNWNpXpY9jAtjRrEEPrhrGMGNTW0Gb0kPZcdW4qqfGRXtsQfZ0e79eapwe0sbR5/9bzLNt/fegSZj7Sw9Lmn1F9WTemn6lNSnwEW18YQHJchGF7wzoRLHn2MhY93ZukOuGGNg1iw5n20MU0iDFurx8Txjf/7cZXd3UzbHfx/i3n8e7NnS1tXr6uo2X72CHtGDOknaXNsIFtLNuf7NeKJ/q2srR5tE9LHu3T0tLm/3q3sGx/oGdzHujZvFJ9PNKnJY/48GPo5a143Mf6uB/7RowY1JYRg9pa2jx3ZXvL9peu7ciEa63331s3nsvbN51rafPhbdYDzr6+qxvf/Nf8WBPAzw9caHq8JsaG8/tjPZj92KUkxhrbJNUJZ/EzvVny7GU0NDkvkuMiWDe6n+m5lRIfwa7xg9jz0iCL89N4eSAJpAhLBdyHEh7Ul7mzDrhOf30NECuEqBdAnwJPXCPj5UHBsH9F9fqiOK2piJA7WZuKCjkMbM4UweiPzdP92xARGswzA9oYtj87UBOKjROiGDbQWHSOGNSWTo3iGTHYuH3k4Hb0aNmAnq0aWArGwZ2SGXJOiqXNjeefZdl+x8VNufPippY29/Vsbtn+0GUtebhPS0uboX1bMbRvK0ubJ/q1tmx/sn9rnuxvbeOrj8f7agLLyubRyzWhZmXzf71bWLbfc2kz7rm0maXN7Rc1sWy/udtZ3NTNev9d3TnV5w+YAR0aWrZf2qoBPVqaH2sp8ZF0OTvB9HgdPqgtbRrWoXXDWIab/NAaNrAtjepGkRofybMm58UzA9oQFxVqem493b8NwUECIYRf53B1Ech05L+A/lLKu/X3/wa6SSkfdrNJAd4DmgIL0QRZeyllrkdf9wL3AiQlJXWZOHFipXwrKCggJiamUn2YkXhkAa23vU+w80TaxClCsQeFE+ooJC1lAPkxzWiybxLhJZmUhNdnd7N/k5HUs9p9rWqUr4FB+eo/S9Ns/LzdRlaxpF6E4LpWoVyUEmpi46ReRJCXTcX6OHmb6vB1aZqNLzeWUupWwhYWBHd0CCuz82VTW/pQvp7avrpsTpVzqyrp3bt3jdSEXQiMlVL2198PA5BSvmRiHwNslVKahJI0an1NGBiPoGw9EOa+CCs+RAvQum13i8L9mq5dqgjK18CgfA0MZ4qvtWFkXFX5oXw9tX2tjVTHdaCmCvND0Arz+wCH0Arzb5FSbnKzqQ8ck1I6hRDjAIeUcrRVv6eECLPitZZQkOG93KRw/0y5UVQ3ytfAoHwNDMrXwKB8DQzK1/LUSGG+lNIOPATMBrYAk6SUm4QQzwshrtTNegHbhBDbgSRgXKD8qTUUmAzXzz0AtuLq9UWhUCgUCkWNEdAZ86WUs4BZHstGu72eDEwOpA+1DrNHHwG82Q663Ald74J9S+Cv5+mZexDWVG7CV4VCoVAoFLUP9dii6sbo0UehkdD9ATi6DRa9rv2JIJAOBGiibfojmq0SYgqFQqFQnBYoEVbduESUZ+G+a3n2XvjwEijJL/85W5H2GSXCFAqFQqE4LVAirCbodIO5mKrbBEoKjNtyD8CCV6HDtXBotbmQUygUCoVCUetRIqw2YlY3FhwG817U/tynuVDpSoVCoVAoTjkCOWO+4mTpM1qrE3MnNBKueh+GboKIePB8rLKtCH5/FgqzTixbPwne7ABj47X/6ycF3HWFQqFQKBT+oSJhtRG3ujGZexDhmW4szjX+3PEseLUZJHWE2IawZwE49KfWq2iZQqFQKGo7RpOde96zfNlUoI+anoFARcJqK51ugKEbWdBrqjaJq/vBYfZ8yuhE6D0SIuNh5x8nBJgLWxHMGQVOx4llKlqmUCgUCl/3An/uFbpNz/lXn1wf6ydpwYLcA4A8ETxwt/NlU8E+hJlNNaEiYaciZtNc9B+nibWeT2kHuWfKEqAgHSacBcnnQGiU72iZP78oFAqFQlFxqiJiU1WRI/d7iue9wFe7Rx+GUysZ9THtYSg4As37gKMEZo8of18D7f1vT2sZIHsJLHzF2Gb6o7BtFmz7HewG7VMf0LaBvQQKj2JY0lMDMxAoEXYq4muaCzAv7o9MgI7Xw6F/tAlhPbEVwawnITwWju3SnndpdeJBrQnrKhQKRa0RNr5sAiVsXO0d/6X9wF43EX575oQwyT0A0x6CrN3Q9BJNlPw+zFjYzHoSju2BZe8at0/To0eOEti/3Dj78st9MP0xsBV67imwF8OckcBI7zZ3irI1X6ywHYf0jd4CzIXTDk0u0Qa4/fOVsU3uQevvCABKhJ2qWE1zAebRsoEvn/icWbSsOBd+uMm4X1sRzB4OjbtDnToPmEsAACAASURBVFTYNMX6IgEqmqZQnAmcCcLG1/fYi6HNFZoY2TgF/npOW+ay+fUhOLwBzuoGvz1rLGxmPgFHNoK9FNZ8bWzz60Pw98eQthacNu/2Kfdof2bYS2DBS7DA3ATQ7gXzx1v0U6RFlULCvQWYC+mErnfCsvfM+/nXlxAcDtMfhsJM7/bYZLhvEYSEwQcXQZ6BWIprDA+v0tKcRgGIuMZwzYfa611zTWxMSn0CiBJhpyuViZbVSYV/fQWfXW7cd+FReLsTBIUAsnyNGZyoPWs1ALb/7vuCBlV3gVYoTidqg7Dxtz1QwsaXzbSHtWtSi75aVMUwnfWsFgmxl8CfY41tZjymlWdsnGLcPvVBWPSGFvXJ3gfS4Lo37WHtzwxHCSx7B5aZm1CSB8v/p4mSUoPokauf8FhvAeZOz2e0qM/cF0wMBPznV01ATfqPlhb0pE4jeGw9vH2OubC5T1dyVuKn/zjY/Kt5e/trtNelBcbBg77PQ0wD7f3lY4xt+uhPRDQLQLja/bWpJpQIO5052WjZ5WOh8fnayWF00kQ3gMtGabP7L37DuO+CdJjQmHLzmbmwFWnh8Yh4iK4PB1bAn8+VD5ef7AX6FBkRo6hBlLDxz8bphHZXwvoftelv3CM6ZemsHpogsEpn5R6AxW+Z1PE8ot2c7SWwZ6HWl6fNL/dp1wuHDUo9niQCml+zh2t/ZhRlaTVBVpQWws65WlrLCKcN6rfQxNGx3eb9DHhZi9jMGGpiIOC+hfDdv7TrpCdxjbXBWGAtbP79i3V7b317rP7SPOrTrKf2ut+LJveCMRAUXDXCxp8+/Ake+LKpYB+GMxBUI0JKg3RULaZr165y1apVlepj/vz59OrVq2ocCjAB97UioX3QTpoh75ywMbsIRNaDSx6FPyrxyyI0EjrdBJF1YdVnxlNzxKbAw6th6wzfvvqzPrXlBuxmY3qRUL5WStiU4X4M+HuMVMam/TVanc6sp8rXr4REaNGL5r01wTHxFr2A2IPIutqPoL+eh+Ic7/awGK3u02GDTb8Yi4rgUKjfWhM/x3Z7R3Wqk8T2mmhJW2Nuc/7dWlRn+QfmNtd9phVwH8/ybotpCHf9rkV9Pu0DeWneNi7xYyVs/BFH/tpUxbFWVcery642XAeqmerQA0KI1VLKroZtSoTVbmrc18re1MwuRLHJcMM32k1m4s3m3x/dQCvKdNpPzv+QCK1GIyxKSzOUGjwSKqqeNhHu/hXaRd7913hIBPQbp93UgsNgyzQtbVHTF87qEAu1wdcr3tZEi9MOG34qX2Ds2j+9R0DLvtrIqAUva8LCRXA4dLsPzr5AEyUzHteiIp5ExMFFD8OSd7R0kCeh0dD2Cq2Pbb8ZF/8GhUL9lppNTQubmCTteDU691y0uUITY5t+Mbe5/Dn4c4xJo3s6699QkOFtUicVHlkD73Y584RNFf/oC/gPnCqkxu9bFUCJsAqiRFgtxOoiUZlomuvCKiW82R7yDnnbRNaFix+zuFEACc2g9Lhx6L+qEMEQ31i7EWfvMRaNweHa6Jx9S06kdtwJjYK2Q0AEaSkaowhGWDR0ulFLERnVi4TFwLm3aK/Xfm8sOsOioeMNgIT1PxmPWgqN0m7SW2cY+xESAU0v1Ypu9y4qL3zK1jcUEtvBkc3GtSsiWBPZ0qFFL6TT26Y2EX+2tk5ZO81t/BE2vUfqjx4z4eaJ2nE09X7jSFhsMty7AD7pbXxOVLWw8acPJWwCLn5OiXuBjvK1PFYiTNWEKSqPXnu2wOhg9ic/76tWQAitTs1wtOcrWl8rPzW/UTyipznMbiYxDeGWifBxbwxHiwL0f0mLkP051rhdOqBRN01sZO0wtnGU6HPdGAgw0MTOgRWaGDGrSykthM3TzAt2Swu0iJHrtVkfW2cAwliAuXw5uNLcD3uxFvkICjYWYKBFhGIawuF1xu3SAa36aWJs9RfGNqCl3oJCrIX2v76En+4waRRw73xNHH1zrbEYr5MKj6yFdzsbD1OPa6wVKIO1KLnpO+31wVXmNj2f0obIm7W3Hqi97j/evEg5Nsn8nKhoAXIV1/IYCpuqqPWpiI0voWN1zapgH5W2UZzRBHTGfCHEACHENiHETiHEswbtZwkh5gkh1ggh1gshBgXSH0UN0ekG7Rfz2Bzv2f9d7UPe0W5ACO2/Z72CLxuz52163myMbPq9ACmdzYcnxzWGCx+ES4bq329ic90nmhiwsrnnL+v2R9fBYxusbZ7eZd3+zF7tz8rmqZ3w1A4fvqy1br9vAdwz19rm1knW7Ve+C0Pesra59Em45DFrm/bXWLQ3gpRzIam9tq+NjoHLx2p1SX3GnPxxVBEbf/pwO+al0TFfFeeNPzb+9OGyM3vKh1u76XWgKm0UilOEgEXChBDBwPtAX+AgsFIIMU1KudnNbCQwSUr5PyFEO2AW0CRQPilqMZX9VVkVI2KqamhzVUQWqqOPM9HX2hKx8acPl11tiNioiI5CERACmY7sBuyUUu4GEEJMBK4C3EWYBOror+MAgyErCoWfVDYNUZtuwKeSWDiVfHXZKWGjUChqAYEUYamAe9HDQaC7h81YYI4Q4mEgGjCZHVShqCZq0w34VBILp5KvCoVCUUsI2OhIIcS/gP5Syrv19/8GukkpH3azeVz34XUhxIXAZ0AHKcsPkxJC3AvcC5CUlNRl4sSJlfKtoKCAmJiYSvVRXShfA4PyNTAoXwOD8jUwKF8Dg/K1PL179zYdHYmUMiB/wIXAbLf3w4BhHjabgMZu73cDiVb9dunSRVaWefPmVbqP6kL5GhiUr4FB+RoYlK+BQfkaGALt64xdM2Tfn/rKjl92lH1/6itn7JpRoXZ3mw5fdjC1qSqAVdJE0wRydORKoKUQoqkQIgy4CZjmYbMf6AMghGgLRAAGE+MoFAqFQqE4lZm5eyb9Jvej01ed6De5HzN3z6ywzczdMxm7dCyHCw8jkRwuPMzYpWPL7Hy12512Jm+fzJilYzhceBjAy6Y6CVhNmJTSLoR4CJgNBAOfSyk3CSGeR1OF04AngE+EEEPRivTv0FWjQqFQKBSKWsLM3TN5+5+3SS9Mp2F0Qx4971EGNxtsaHO48DDJk5PL2bjEUbFDmyfRJXwAnzaljlJ6NOrBcdtxXlv1Wlm7i2JHMS8uf5FNWZuYvH2yYfvwRcPL9e1JsaOYt/9522udAo1PESaEiAaKpJROIUQroA3wm5TS4vHtGlLKWWjTTrgvG+32ejNwcYW9VigUCoVC4RcVEVBGNicroMYsHUNmUSbdGnbj1ZWvGoqjF5a9wPLDyym0FbLw4EJKPB7iXuwoZvRS388gLrAVMHn7ZIqMHikGOHFyU5ubiAqN4oO1HxjapBcG8KkqJvgTCVsI9BBC1AX+AlYBNwK3BtIxhUKhUCjOdKyiS+7tZgKrMgJqb+5ezk08l5f/ftlQQI1dOpYZu2dQaCtkQ+YG7B6PaytxlPDaqtcs16/QXsiytGXEhMZ4CTB3hncfTkxoDK+ufJXskmyv9uToZOZcP4d+k/uVpRk925/o+gQAv+z4xdCmYXRDS18DgT8iTEgpjwsh/gu8K6V8RQhh8bh7hUKhUCgU/gikyggoX+Ip35bPSyteMhRQo5eM5vst31NgK2Bv3l6cHs9uLXGU8OH6Dy3Xr9hRTHZxNjGhMV4CzJ23e7/Nc8ue41jxMa82l3gCLAXUzW1uBiBIBHmlFSOCI3j0vEcBePS8Ry3b/bWpLvwSYfr0EbcC/63A5xQKhUKhOOWobPrO1V5RATV66Wh25eyiQ/0OFNgKTCNQo5aM4tMNn7I7d/dJiSeAUmcpMWExJEUnsTt3t6ndNwO/4fH5j3O0yHvMXHJ0MhOv0KaMshJQl511GUX2oioRR65tbLbtfbW7bKLnrSb040nE5zrIiQvGdu8QelVzPRj4J6YeRZte4he9sL4ZMC+wbtUM/px4CoVCoai91FQB+eilo9mZvZMO9TuQb8s3rYEatWQUH677kP35+70EVKmjlE82fOJzHW1OG2fXOZudOTtNbb4Z+A3RodHc/+f9ZBzP8GpPjk7mo74fAdYC6tzEc3mi6xOVFlD+iiNfNgCXbHLS6gMH9sN2QpIdJA51QjP/23OnT6fhu78gix0AJOQ6EO/+Qm5iZ+KGDDHdpoHAUoTpz38cIqW80rVMao8heiTQjlU3/px4CoVCoQgcNVlAvjd3Lx0bdGTC3xMMxdOYpWP4fuv35Jfmsy9vn6GA+nTjpz7X0ea00TqhNXvz9pra/HjFj8SGxnLn7Ds5cvyIV3tydDJv9X7Lp3gCeLzL49UuoA4XHiY52rt+zZc48scmd/p0Do8ajSzWfLWnpXF4lFa4HzdkCDnTppE+ekz59hEjOb56NeEtWuLMzyPr08/K2l3I4mIy3nyrdokwKaVDCNGlupypSd7+523DE68mhqwqFArFqUZNFpCnFaTRObGzZQH5Lzt+Ia80j+3Z23FIRzkbf1J4JY4SokOiSYpKYk/uHlO7SVdMIiYshjt/NxdQr/V8jfVH15sKqHb12gEwtMvQStc/VVUEqiICypZmJzSlvI0v8WRqM2IkRRs3EdGmDc78PI6++56hgEp7dhjpL47DmZvrtU1laSk5E3/0Wu6J/bD3/gg0/qQj1wghpgE/AYWuhVLKKQHzqgYwG5paE0NWFQqFojYRiPqnsUvHYnPauDjlYvJLzdN3zy17jj/3/Ul+aT6rM1YbjsB7Z807lv4XO4qxOW00iGrAlmNbTO2+H/Q9j8571LT+6eN+HwPW6bu29doCVS+gjKJLVZW+82VTUQElXDYjR1GyZy9R53TiyLjxhuLp8IiRHPviSxx5edgOHQKPqUJlaSnZX33lta29cDiIGzKE7G+/NW4XgpZLFhMcE8POAQOxp6V5mYQkJ/v+nirGHxGWAGQBl7ktk8BpJcIaRjesNUNWFQqFoqoIZIpvUNNBFNmLeGP1G6YTaK47uo6pO6ea1kf5oshexJ7cPdQJr2M5Au+Tfp8wbNEwMosyvdqSo5P5aqB2I7cSUB0bdKyS+ieomgJyl93gZoOZP38+vXr18vK7suk7Kxt7Tg7R3bpxZMLLxgJq9BhyZ8zAmZtH0caNYC+/f2RJCVkffECWl9duNqWlhCQmEtaiObaDB42NhKD5nNkEx8ay+5prDSNWISkpNBw5gvy5c00FVkhCAgCJQx8rt74AIiKCxKGPWXgaGHyKMCnlndXhSE1jdFKFB4fXyJBVhUKhgJpL8Y1aMopV6atoGteU/637n+kM5CMXj8QuzYVRga2Ambtnmk6gCTCy+0hiw2J5eeXLplMYTL16KmAtoC5IvoAnuz5ZqwrIXQLKDH8iVLnTp5Px5lskpqWxIyWFxKGP+RRPoAksZ3ExGa+9biig0p97nqI1a3Hk5ZH/xx/IkhIvm4xx4019B5BFRTgyswiqE+slwNxp8uNEDj78CPYM7wECISkpNP7wfwAcX7XaVECFNW4MQOLjQy0FlD8CK27IEPYcCmb1ymKKQ+KIsOfS5fwI4oYMslzfQODPjPmtgP8BSVLKDkKITsCVUsoXA+5dNeJ5UkkkfRr3UfVgCoUiIARqjqisoizOSzqP3JJc0yJz1xQHuSW5hqk3m9PG5B2TLf134uTO9ncSFx7HZxs+I7fUuxbHnwk0b2xzIwASWWsKyH2JJ39tXALKfvgwIcnJFRJQnjZlKb4RIzm+di0RLVqQ8cabxvVRzzzL4ZGjvISVO86CAvJmziQoLs7SLvXtt0l//nkcWd7xrJCUFJr+rB0nOy7rYyygUlKIPOccEp960qc48ldAAabb1R+BtX1FOis2R2EPjQCgODSeFZuDiFqRTqvu1Zv98icd+QnwFPARgJRyvRDie+C0EmFQ/qS6ecbN7MkzL75UKBRnLoFM8Q1oMoACWwGvr3rdUEA9v+x5Fh1axJ/7/vSaYbzEUcKrq1716b/NaaNJnSbEhcfx846fDW0EgsU3L+b6adebCqjHuujRh6jEWlNAXhEBZZbisxJP/tqYpviysojq0oUjL00wTvGNHEX2t9/hyM2ldP9+cJYfhSlLS8n57nvL9cPppO5ttxJcJ46szz83LFYPSU6m5by5gLWAqtO/H7K0pNICypd4ctn4E6E6kng+yy54noJjJcQkhHNhYnPi9DYrgdXy/CRKi+0snbITe2n57WovdbLs1121UoRFSSn/FkK4LzOPO54mDG42mJdXvszunN00i2/m+wMKheK0IFApvtFLRrM2Yy3N4pvxzj/vGAqsYYuGMWzRMCTli5PdOW4/zrqMdZaPeHnvsveIC4+znGTzzd5vArA0balpPWydsDrVWkBeFRGoigiok0nxAWRPmcKR554viyDZ09JIGz6C/L/+IrRhMo6cHPJ++804xTfhZcv1kyUlBEVHE5qaQunevcZGQtBy4QL23HCjaX1U0lNPARCakmwsjh4fWva+qgSUy8aWlkaox3YFa/EE/kWotq9IZ953W8tEVMGxEuZ+s4XDu3Oo2zCGFdN2GQqsP77czJ9fbvas+y9HwTHzcypQ+CPCMoUQzdGK8RFCXA9U/zjOamZA0wG8uupVZuyewSPnnXbToikUpyWBmqjTKZ30SO1BTkmO6Si+sUvHMnn7ZHJKcgxnMi91ljJx20RL/yWS+zrdR3x4PB+t/4ickhwvm+ToZH677jfLFF/Pxj0Bqm2STZedVXTJH4HlDwFJ8Y0cRemBA0R27Gg6ii9t2HAyXn8DR06OVzsANhv5v89GREUR7CPF1+iDDzg8ejSOTO9BBCEpKZz1+WcAHF+7zrzIvEEDn/VR7uvtr4Ays/EloHzZGImned9txeFw0rhtPYoLbSyevMNQQM39disbFhyi5LiNnCPHvYSUwy7ZuMB7O5VDQpdBTQiPCmH1b3spLvSOJcUkhFv3EQD8EWH/B3wMtBFCHAL2ALcF1KtaQP3I+nRv2J1Ze2bxcOeH8YgEKhSKGiAQE3WOWjKKlekrOavOWXy8/mPjIvTFw336VuwoRiItZzIXCObeMJdbZt5iKqAe6vwQAHUj6p5SKb6q4GRTfAB1rriCjNffMC1CP75qNY7sbArmz0eWlpa3KSkh8513rZ2z24m+8EKC4+M59sUXxjZC0Oaf1YB1ii/2st44C5+ulhSfy87XJKQnI6CAsgjVthWHmf/tNuy2EzZ/fb2FfZuzqFM/knV/HjAWWF9vtfQLwGFzEhwaREJKDNnpx03t7nzlEn56aSUF2d4COCYhnO5XalmtqNiwcusDEBIWxIVXNffpS1Xjjwg7JKW8XAgRDQRJKfOFEAmBdqw2MLjZYEYuGcm6o+vKZh9WKBQVJ5DP4iuxl9AtuRuvrXrNdKbzSdsmkV2Szb7cfTgpfyOwOW2mdVHuPHP+M8RHxPPqyldNR/F9OeBLwHwUX8PohtSPrH/Kpfj8wSrF595eIYE1chSlh9OJ6tQJR/Yx0l8cZ16IPmKkl7hy4SwoIP+PPwiuW9fUBuDsH77n0KOPmY7iS3lJGy2YN3u2z3mmakuKDzQRtezXXSdsrmpervbJUGR9u5WiAhspLePNI1TfbOGfOfspLiilMNd7uzodku0rjoAAiww7PW9pTUR0KAsnbqMo3+bVHpMQztVDOwPw1fAlhmnDmIRwouqEceHVzX0KLNe6W22T6sIfETZFCHGVlLIQQAjREJgJnPYz6fc5qw8vLH+BmbtnKhGmUFgQkGfxLRnNhswNNItrRnZxNp9v/NxYZC0bY+lbiaOEkKAQWsa3NJ3pXCBYfstyrv71atMI1W3tbiuzPd1SfL6oiIAqS/G5pQENBdbwEeQvWEhYcjL27GPkTZ/hXUNVUkLmG2/4dtDpJOE//yZ70k848/K8mv0tQo/q3LnaRvG5bAIdodq+Ip15324tH6H6ZgsHth6jTv1IigtsbF6S5i2ybE4W/7TD0jeHXVKnfgSJTWLZssS8SumB93vzzcilpuKpw6WpADjtTp8C6sKrrEWWvwKrVfeGtOreUD+3LrZcz0DijwibCkwWQlwHNAamAU/607kQYgDwNhAMfCqlnODR/ibQW38bBSRKKeP99D3gxITF0LNRT+bsm8PT3Z4mNCi0pl1SKKqdyhSqD2w6kDdXv2k6ym/u/rlkl2Sz5sgar/mmSp2lfLflO798fP6i53lz9Ztkl2R7tSVHJ/NZf63GxipCFRUadVqm+PzhZOqspN1O9EUX4cjKMh3plzZ8BEfffsd4JnSbjfwZMyAkhJC6dS1rqM766iuC68Zz4J57sR/xfhRQSEoKiU8+SXjr1tVehG6VBvSnEL3CEarvtuJ0SBq1rcuSn41H+c39disbFx6iqMBGTsZxryiU0y7Zukx7GkxYZIhXH+4MvL8j87/fSlGecYRq0AOdADiw5ZipyAoKEj7FE/gnoPy18RXV2rJoHosmfk1+5lG2//QVPW76D2179Lb8TCDwZ7LWT4QQYWhirAlwn5Ryqa/P6Q//fh/oCxwEVgohpkkpN7v1PdTN/mGgc4XXIMAMbjaYOfvmsDxtOT0a9ahpdxSKChGoqRQyizI5p8E5ZBVn8dKKl0wn8xyxeITXc/pcHLcfZ3v2dhIiEkwn/BQI/rj+D+pG1OWKX64wjVJd0/IawoLDqj1CZUV1iKyATaUwYiTH164jvGlTjr71lvFUCsN818lhsxHZubPlTOhtNqxHCGEZoYru3g2AxCefqJYUX2UjVOA7SmU8ym8rmYfyqZcaS1F+KX/P2GMosv762vzRS6DVUAWFCOo3iiHniHkN1f3v9SI4JMgyxdfs3AbYSxzVHqGyXL/SLZTkfk1xTiahwfVxlP4HOPGZMoGVlUlsvfpeAmvLonnM+fg97KXaOudnHmXOx+8BVLsQMxVhQojH3d+iRcHWAhcIIS6QUvqKEXcDdkopd+v9TQSuAjab2N8MWOcVaoBLUi8hNiyWmXtmKhGmqFUEcrb0RQcXkRSdxA9bfzAUWK+tes2nf06c3NvxXiZunUheqXeKKDk6menXTAesI1RJ0UlA7Zqos7qo7FQKOVN/JX3MmPJTKQwbTu70GYTUjceemUXhihXej5spLSXnO99RyIbPPUdIvQQOj33OdKRf6quvcHy1+UzorkFP1Znic9mYpXlPNkIFmoiQTsnSX4ynSpj//TZ2rTnK3o2ZOO3lQ1QOu5M1cw5Y+u6i162tWf7rbooLzGqozgMgfY+5wAoOCQKqRkBVeYTqJAXU5kXz+OPjd7HrtX/5mUf5/X9vs2PlcmISEijKy2PH30tx2MpvN3tpCYsmfl3tIkxIk0kzhBCWgkhK+Zxlx9pUFgOklHfr7/8NdJdSPmRgezawHGgkpffPZiHEvcC9AElJSV0mTrQe5u2LgoICYmJi/Lb/IesHVhWuYnyj8YQHVe8Q1or6WpMoX6uWlQUrmZ4znWxHNnWD6zIkfgjnx5xf1vbDsR+wyRMXklARys0JN3N+zPk4pIMxh8aQ6/CepDFMhNEkvAn5jnzSbemmc1IFE4wD4ygWwAOJDxAbFMtHRz8y/J66wXV5vtHzPn31Z3382SYVpaaPgYgVfxPz668EHTuGMyGBgquuoliP+LjaY7/7jiC3QnJnWBj5N99Mabu2JIwbT7BB/ZMMCcGR2ICgvHyCCgoMv1sCzoQEnHXqELJ3L0ZjvyVw9JWXqTdhAsHHvNO8joQEMsePs/b11lsp7t7NZ7u/26SqyNnrJGM92I5LQqMEiZ0gvklQWVvaSnC/E4lgSO4CMQ0F9mLYt0BiOE2bgJBwsJdgWYgeHgcl3qdMGS0GC0LCYefvErtBICs0ClpdGWTqa8r5vtfH3ab8NtH6d98mFcXs3Mravpm0FYspLcgjLKYOKd0voV6rduXa9y2Yg3T7USBCQmh8cR/qpDbGVnScXb/9gr3Y+zFYIiiIkIhIbMcLTf0KCg0jJDKS0jzzjd/lAb+qrSpE7969V0spuxq1mUbCfIksPzA7r424CZhsJMB0Xz5GmyaDrl27SqNfLhXB7NePGdHp0SydvRRHEwe9mlXuuytKRX2tSZSv/uNPFGvS0kllUZ9sRzaTcibRuEVjOid2ZsYfM8oJFgCbtPH9se+ZXjDdsDbKRaksJTI2kkYRjTh8wLiYViBY85819P+5v2kK8MGBDwKQsDvBMEL1zEXP0KtZL3rRi3a721murz82LruneMp03SpCoI8Bn3VWP/xQFvUJPnaM+B9+oH69BCI7dMSemUn6zz/j9BjJF1RaStxXX1l+r7Dbqdu+PcH16pEz8UdjGyHosHQJYF6oHpqSQs8rryRXCMMIVeNhz9LBtf169SK3XVvzFJ9bu1XqlF694JmnLdfPnyiVr/Zt/7iiPgLbcUhfFUT9mFQSGkazY91OpMMjMuiAtL/BUlnpza26phAZG8rGBYcoOW48F9Xt4y+2TAH2H6IVijeOSzeMUPW6sc2Jwvu21uvrr40vfEWoytlkHiW2foNyNlsWzWPdor/KIlilBXkcWPgHDaIjqN+4Ccdzc9iwdF45AQYg7Xb2L5jt0z/pdNK6+8VsnDfHxEIw9NspAHz8f3eSn+k9iXFs/QbVfl/w59mRfwD/klLm6O/rAhOllP19fPQgWgrTRSPAbDa1m9DmI6uVdEnqQlJUEjP3zGRQs+p/wKfi1KOidVZjlo5hd85uWia0JKsoi3fXvGuYBhy3Ypzl99qlnX5N+lEvoh7fbfnO9Hl+3w76FrBOAwohqmQqBZdNbaih8odA1lkVLF9OWEoKWZ99blhndfS11/3yMWn0KDLffQ9HtrfYDklJodG72pxXBQsXVctUCi47qxSfP2nCyqYBDUcCfr2F3euPEl0nnOP5pexZexSHQRpw3Z++04C9bm1NZGwY87/fRlGe95QMMQnh9L6tDQAJDaMtU3xVWajuS1BVNg3oTw3Vxnlz+POzD3HY3NOAb7FxwV9ERMew1h9NOQAAIABJREFUa9UKHPbyPxwdNhsrp02x9MvFgAeHElUnjtkfvk1hjvdxH1u/Af3vf4R9G9aYCKz6Za973PSfcusDEBIWTo+b/uOXL1WJP6MjG7gEGICUMlsIkejH51YCLYUQTYFDaELrFk8jIURroC6wzD+Xq58gEcSgpoP4ZvM3ZBdnUzeibk27pAgQgZrPatSSUczbP496kfWYsmOKl8AqcZTw8YaP/fLxjV5vMG75OLKKvR+omxydzMgLRgJwVp2zas1UCrWJytZZGdmkDR9B7u+zCYmPw370KIVLlxnWWeX97PuGc9ZXXxHSoD777/ov9vR0r/aQlBQSbrmF4NjYWjWVgi8qI7BadkvCVuxgickz/+Z+s5V/5uznWFqB12zqTodk1+qjhEUEExUX7iXA3PnP+IuY8upq08k+2/fQplLwp1Ddl4CqzqkUTrbOymGz0ah9J+Z/81k5wQJaDdXsD99m6U/fU5ibg80gReh0ONi/cR11k1O9BJg7d731EVFxdfnqqf8zjVC179kHgJ633WUpoPwRWK51N4vaVSf+iDCHEOIsKeV+KKvf8hGTBSmlXQjxEDAbbYqKz6WUm4QQzwOrpJTTdNOb0SJrPvusSQY1G8QXm75gzt453Njmxpp2R3GSVHY+q+k7p/Pc8ufKntt3uPAwIxeP5JcdvxAZGknm8Uw2H9vs9cgam9PG7H2ziQ2N9RJg7ky5cgr1I+tz44wbTdOAfc/uS6mj9IycSsEXlZ3PKuONN41HAo4ZS+6MGdgzjlKybZvXQ5Wx2Sj86y9CGjQgpEEDLwFWhhC0WbeWnQMG+h4J+MTj1TaVQtWKLCf75iwpJyjMBJZEclb7ehzPLTWdEPTPrzZ7CR5PHHYnsfUiyDpkXAMHcM9b2qOcrNKAsQkRVTrZp68IlD8RKl+clMD66F1yjqST2LQZhTnZLPz2c2OR9dE7lt/tsNtp2KIVUXHx/DPrV1O7u9780DIFWDdZE7cVFlAG6+yr3cVZMe0Z0vgB7LHFhMRHUCemieW6BgrTwvwyA22ur4+BBfqiS4F7pZS+k7QBoGvXrnLVqlWV6uNkfq1LKbnm12uIC4/jq4HWNRlVyakQWXBR075WNEIFmnAZe9FYBjUdRN/JfTly3HsOovDgcFrGtySjKIOM494zaQMEEUTzus1JjExkSdoSQxuBYP3t6y2f+Tfn+jk+fXUXjb4iVNVNjddZGYiW5BeeJ27IEJyFhewaOMhwNnRCQwmpV88w8uQiol07QhITKZg/39hACNpu0QZ/W0230HLuXz599Vxfs6kUqouKRrEAgkODOH9wExo0jmXO55soMXhWn7+cc3ljouqEsWb2PtNn/vmqs7p9/MWmvoaEBdH71jblRGN1zKZeFXVWnqIlODSUDr36Ep/UkIKcbNb9MQu7xRxsvuj/wGMs/O4LigyK2WPrN+De97VHOFmJrHvf/8LQ15CwcPrd+5CXaPS1TXxRuCaDvNl7ceSUEBwfTp3+TYjunFiuPWfKDqTtxDEgQoOIv7ZlObuqQghR8cJ8F1LK34UQ5wEXoBXbD5VSeo9FPs0RQjC42WDeWfMOaQVppMSk1LRLZxwn+9zA3o17k3E8w/TByyMWj2DUklHYnMbh8hJHCXHhcbSo24KpO6ca2kgkU67UUk1WdVZQ8Wf+nQpTKVQFJ/vcQCkh9tIeHHnlVdMHL6c//wLO/HzzL7fZiL7gAvL//BOnwYjCkJQUmk7RHm1kKrBqoM6qqrASHYbzWX27lazDhSQkR1OYU8KqWXu9IlUOm5PlU3f7/O5LbmhJdFw4C3/cZjoh6CXXt9Rex4XXmjorf6hsndWmhXP585P3PKZbeIsN8/8kPDKK3WtW4vSIujpsNtb9MUtb99Aw7DbzxzTdOu4NouLrMnH00+RnGQuoDr0uJzg42GeEylcUq6IRKkesLqAMIlRWIstTYDlySsj+eTu2jELCGkbjyLeR98e+cgIMQNqc5M3eGxARZoU/6UgAB5ABRADthBBIKRcGzq3aycCmA3lnzTvM2jOLuzveXdPunFac7JxXeSV5dGrQiZf/ftlQYA1bNMx0CgYXDung9va3M3n7ZNP5rD7s+yEAKw6vsBRYcGbWWfmiMgIrpscl2NPTTWdlP/z005g/MAWw24m78kpCkpI49vnnOHJyvExCUlJImfASudMvOqXqrPzhZGqx/vpmC/u3HCM6Ppz1c70fvOywOfnn931+ff+1T57H7E82Gj5bMCYhnHMu08Zv+fPImtOhzgqg9cWXsvD7Lw1TgHM+fpfVs36lMPsYBdnezyh1Ohwc2LSeeqmNvQSYOw998SNhkVF88tBdphGqhi1aAdDj5soLKH/qrHwJLCMBlTNFe3SSpciavJ2ijUcJjgmjcHUG2D1S13ZJwTyTCYPdcOScfMTwZPFndOTdwKNooxvXokXElgGXBda12kej2EacFXsW7695n3f+eafWpIBqOycrsLKKsmhXrx0ZxzMYt2Kcocga//d4y++WSB477zESoxJ5bdVrpg9eHtplKK3qtqp0ITucfnVW/nCyxe6xffpgsxJYzzzj9bgbI5KGPUvmhx+ZjhZsOEobrBCa3PCUqrPyxUkJrK+3sHfj/7N35uFRldcf/7yzZk/IHvawKCJEZBFRUEBU3C2tS221daOtUrdqlbZSW39trVVBa93qTjWoERAFZAdlUVYJsoZ9yUZCtskyycx9f39MEkPm3juTZJLMhPt5Hh8yd+5975vJODk553u+p4iIaDuO0hoObS9CcZ/+Gisuyd5v8jGZBIqi/frf9tRoIuPsZP71W80yYNqAOC6aMqDr66zeeBkJpA8bgeNUMavef1M1yFr8ykwWvzIT2VxX2HhOLRExsST1Sef7Vcs09/jL51/RLQHaIyKBwOisGs7xVRbU01n5E2CVf3lYNUNVOjeHqq0FuMtrcamMYcItqdl5ClOkxTsAa0LKw8MxR9soeGmbasBljutYH1DwLxP2IDAK+EZKOUEIMQhoq4dYSLLw4EJyK3MbR6yoCbfPRFojdi+sLGRQwiAKqgp4duOzqgHWvzb/y6/7vzjhRZ7+5mmKqr2r5GmRadw99G7A0+UaSMf1to61CRVaK3aXUhI5+kIK/vmsepnw934EWFKSMv0JLKlp5D/9tKYre/wvfoE5Pr5FGaq2jKzp+CyWf2L3Fe/v5tCOIsKjbDhKajjyfbF3gOWW5GwqxGI3ExVn93q+Kb9+eTzv6wxe7pbq+UXfkSNrAoHe3EDNTkGXm57nnIvjVDEr3/uveoD1sm+LEakojP7RLWxfupCaSu/Sd3RiElOme37FHtnxnXqQleCxWwhUgNVwnl6Q1RKdlUCcFmSFD06gbNEh1QCr5NN9VKw8iru8FulUN4eWdQpKjRtLQjgunTFM3Z8cQ94zGzUDLGuK5/0ac2VfVU1YzJV9NdduL/wJwmqklDVCCIQQdinlnnpbiTOOF7e+iEs5Pf1b467hxa0vdplfuM1pTRZrxvoZ7C7eTd/Yvjy/+XnVAOuFrb6mXnl44/I3SIlI4VfLfkV+lbdoOi0yjYm9J1Ltqj7j/KwCRWuGNwPETJ7syWI980+NMuHj+jeWkqRHHsGalkbBP5/BXeRtudEQYAHIWmdI6ax80dos1p5v87HazRzOVslguSX7NxdiC7cQ1U0/wJo66xKEELpidhHgwcsdGmC1KIv1byqKi0jq24+V776hYccwy6/7T/jFvUR2S2DlO69RVeZd+o5OTGLsrbeT0KNnh+ms/MlitVRnVTo3B+lWCEuPxV1RS9nnB9SDrI/2om0dDbgk1tRIwgZ2o3JrAbLGOxAzx9lJuX8YgG6QBf4FWI2ZtyWHcZXWZ+2aBZUdhT9B2HEhRByeAd7LhBAlaJuudmnyK9U7p7SOhwItFbvPWD+D74u+p3dMbwoqC/hwz4deQVatu5b3dvnuIH3nyndIiUzhriV3qb6GaZFpjOk+BoCHRjxk6KzaAV9BVuG/nlPPYj3+BLmPP+Ft1dCM1D/P4OS/X8Z9yrsMbOnencSp9zasGlI6K39oqdh9xfu7ydlSgD3cSsWpGvIOlNLM6QTFLTm26xTdUiN0A6x7Z14C6NsxNMxsDHQWqy06K39oudj935SdLCSpTzqOU0V89YGaFquWrzN9f2Zd+ZuHiIpP4MtXZlKpoteKTkxi+NU3AKC46jpEZ9XWAKvheW8xew6uU9XY0qIoXaAeYJVm5fh8zQBir+pLxZrjKCoTBMxxdhJ+dg4A1l7RPgMoX0FW0wBL6/ttOC/y/OT692vgR2P5iz/dkT+q//IpIcQqIBZY3K67ClJSI1NVRdkSyR++/gO3DLqFjMQMFh1a1O7WAe1pKrr62GoSwhP4dN+nqgHW/3Z73NYtwtJYmlVj2U+WccfiOzTtGEamejp2HxquH2DBmamzCgR6WS6pKBQ+97x6kPWEjyBLUUi87z6sPbpT+MJM3MXqWaxuP/0ppqiogARYDecFQ5DV6izWN3lYbGbNMuHh7OJGv6rmAVhTbnvqQt0Aq4EzIYu15PWXKDx8iLjUVM0Aa91Hs/26/61/eZYvZv0TR4n3+7mhUxDg0p/d2WE6q4ZztP5wbHWAVViJNSUSd1kt5SuPegVZuBQqlh3V3RtAt58MxBxj59Qne1EqvLtbzXF2oi/thSnG3qIMldb34+85nZHVag3++ITNllLe7utYR9FZPmGg7t1kN9s5P+l8souyqXJVkRaZRlF10Wl2B63xdzpNZxWpr7NSu8fnBz7nLxt+MBUFsJgsjEkbQ7QtmqLqIrYUbMGtPq6TSGsklXXqg1AFgpU3ryQ+LJ7Jn07W9bzyZ6/+viaBJJQyYVp7bWnHIQBmM7aBA6C2jrrjx5G12u3riff9hlMfZqJodBMOXLlC8z7NPa/8GQXU0Wi9rq3xxDKZBf3OT8IeYaWiuIbju09pCtrju0dyKld7yPD9r3l6nnx5Xvnjd+XP9xNotF7XlgZYAGarjRFXX0+3tB6UF51k8+dzqXNqmx3rcdvfnic6PpEPn3w0aPys/KEhyFIrm6n5XWERRF3cA2tSOO6yWirWHEPqGN36Ivn+YRTN3oWiMqbJHGcn7YkLNPfS3HvLV8DYGXTE7wI9nzB/grCtUsrhTR6bgR1SysE6l7UbnRmEgXawUFlXycKDC/nHxn946cYAoqxRPDziYQ6VHeLjvR9Tq/zwhlYL0tSCvfuH3c/wlOH8duVvKanxrrLbTDZ6x/SmpKZEdaRNAz2iepAUnsR3J79Tfd4wFQ0O9Iw6VQMfq5XI8eMxR4RTe/QY1du3q2eyLBaiJ07E2qsnpVmfopR5mzCGqqmoP7SkTAhgtpg4Z2wa0d3CKC+uYc+GPNzNswb1hEVaiU4I4+RRbU+y+1+bGHKmov7QUlNRi83GBTfcREKv3pSfLGT9Jx+qjr7xl6mvvkvmk4/pBljaezk9yOroAKslpqKYBRHDk7HE2qn46nibAqyUR0ZgjrFRMGurps4q7YkL/DY31QsYg5WgDcKEENOBPwDhQEM7ggBqgf9KKZ9oh736pLODMF9kvJfh05dKC6vJisVkocZV0+o1JvSaQHxYPJ/mfKr6fEOABdqmoq3NYmmJ3YORzg7CWpPFEjYbMTfcgCU+nlPvvedVRmzAkpqKrVcvqjZtUr95E2f3QGexOvt1ba2z+9BLexAVH8a3nx2kTqNDC8AeadF1fg/1LJYWrc1ijbzuRrql9mDVu6/jrNLuavPF3S+9SVR8Am8/NDWwWax2nhvYErE74AmwRqRgibXjLnNSuVXF86oBge4AwdTfj8IcYyP/uc26AZbWXtqSxersz4GW0NlBmKYmTEr5D+AfQoh/SCmnt9vuuhhaurG0yDT+d/X/mPTJJM0A647Bd+CWbt7d+a7m+q9c9gpPrntSc3jzSxM9s77W5643TEWDFC0xvFJZRdg5g6g9fJj8p//PW6tVW0vZJ5+A2QxujUBBCAauXgX45+ze1cXuqz7YQ01VHUm9oikrqubrj/apGo9+t/yYz3vfO/MSbOGWgGixQl/s/jKVZaUk9Umn/GQhq1U8sdx1tXw792Of9779ny8Rk5jM+4//VjPAikvxvC6B7hZsy2dWq7RYWfuo2VOMOdKGY2O+d4DlllRt9DQpmSKtup5XPZ6+WDfAssSHAS3vFuwKOqtQwp/uSK+2ASHECinlZe2wn5BHL7BJjkjWDdIeGuERKi85vETznHE9x/HYqMcMU9EgRyt7pNTWUqgxXif/qad8LywEg77bxv4rJ7d5dE4DwRRk6aEVZCmKJG1AnOYA6K8/8q+D685nx/LJM5s0AyxbuOfj8kwQuy9942WqystI6qNt2bBm9lt+3f+uWa/zydN/0hyLk9y3H9CxpqK+aG2A5TxQijnGhrvUSVX2SXA1+4PbLaneXoSwmX0GWMJq0rVjEBZTwAKshvOMIKvj0QzChBBhQCSQKITohif5CRADGIMTNfAV2PgTHAUiQ3Ummop2FP6VEp9E1ng+PF25ueQ+/gT5/3jGI3LXsXXo+cor2Pr25ejdd+PK8w7ELWlpCKs1YKNzggm9LJfbrbBu7n7VIGvFe7t9rn3ttPOITQrns1nbcJSoB1kRMbaABVgN57V3kNUWZ/c+Q4dRVpjPyvfUg6zV77/p8/43z/g7MUkpfPSXJzSzWN3SevgciwOB9bzyRUOQ1b/URN43G/2aPVh7vAJLfBjuEieV3+Z5dxO6JVWbC0CAOcbuHYA1oftfxpD/z03aAZbVBATejsEg+NDLhP0KeAhPwLWFH4KwcuA/7byvkEYvsGlpAGWYinYsrZpx+Mc/4fh6LaawMJwHD1C9dZt3oKUoyKoqEn/9K0o+zNScXxg90fPLJfmRhwNqTNrZtMbSYfl7u9my9AjuWoWK4hrd8TkTbh/EN/MPUK3SIh8Vb6fPkAQAxtwYWs7uevgaAF1X62TNB++02tkd4KYn/8ail5/X9MTqdW4G0LGmor5ojbN7Y5AVZ6d8uZpdg6RynSfzLKwm7+eb0OP/xiLMQj+LJUTATEWNACu00dOEvQi8KIT4rZTy302fE0JY231nXZiWBFCGzqrj0BsiHTlqJM79+zW1WuULFmCOjcXWv79mpks6nSQ98AC29PQOG6/TUbR0vM7K2bs5vq+E8CgrJflVHNlR7BVkSUVSml9F+nlJDBiRzPdfn1AVxUfF2xl8cXcsFlNIlQn9QW+8ztdz3tdwdn+Rrz54R3X4c1Mm3vkrYpNTWfrGvzWDrN5Dzmu5J1YbTEX9oTXO7q7SGmxJEbhKnJQvP6IbZOmR9qfRmCKt+lkssydf0dVMRQ3aB3/MWv8NIDz2yhOA24DrgBRf1wohJgMvAmbgTSnlMyrn3Aw8hafPY7uU8rYW7N/AoEXoDZounDmr9UOkhWDgNxsQQvgUxIfaeB1fqGq1/rcHR5mTuKQI1sxREcO7JLvX5WEyC2KTwjWzXIpbMnnqEADi0yJDSuzui9aUEr98dRZbF3+OorhVy38AbpeLPhnDiUtJZcviBdRUlHudE52YxPmTPe83X0FWsIvdS+fm4K5wYk2J1HR2r1hyxK/7d59xoe5wZ3OUDTDE7gaBw2cQJoQYjSfw+hEQD9wPPObHdWY8ZcvLgePAJiHEAinlribnDASmAxdLKUuEEMa70aDVtGbQdO4f/kjZ51+Ay6UaOAGeIdIzniRs4EBOPPYYrvwCr1MsaWmNY2D81WsFSxbLF3qlRGe1i7Wfqmi16hQ2zD3gc+1fvXQpJrPJr47DkM1i+dlxuOT1lzi6M5uwqGhK8/M4uHUjSrMuWMXtpvDQAfpkDMMaFq7qqxWdmMTk++rL1skpIS12L52bg5SS8AHdcJ2q1pxPWL7osM/7J08bhiU+TDfIMkVYDbG7QYeiJ8z/G3AzcBTIBP4KbJZS+h6w5eECYL+U8mD9enOAG4BdTc65F/iPlLIEQEpZ2OLvwMAA/RmIkRdfTM3u3aqlROrqqPzqK8IGD0aEhyOrvX+pWbp3J/42T4I2+Xe/O6ME8Vparc1fHqa2ykVlmbbjPsBPnhjJl6/v0BTDm8weAbI/gngIniCrtUOiT+WeIDY5hVXv/VfF0qGO71ctw2yxEJuS5hWANaBIhSnT/6LpidVZYnc9tAIs8AQq0qVQtuiQ+nzCj/fhraD0JunXGRR/uEfT2d3WMxowxO4GwYVeJmwqsBd4FfhCSlkjhGiJg2gPoKn5znFgdLNzzgIQQqzDU7J8Skr5ZQvuYXAGoZfp0iol+jNkGiFIn/uppnFpKM849IWWXuvo7lNY7WZ2r8vF7fLWapUVVjNwVArdUiP4bvkxahzqgviUvjE+xfDgfykxGNATxA8YNYaS/FzVIMtVW8s3c+f4XP+B2Z9iMpl54/471TsOExKB4AmwGtDrOCxfclg1wCr5dJ8n2Clz6hqPxt3QH0t8GKeyclAq1IMse99YYq9KN8TuBiGFnmO+GbgC+CkwEVgFTAJ6SakztfmH628CrpRS3lP/+HbgAinlb5uc8wVQhyfj1hP4GhgipSxtttZUPEEhKSkpI+bM8f1BpofD4SAqKqpNa3QUxl49hH27kegPPsDUZNahtFqpGnsx2GxELFna2L7bFAk4fvxjXL16EvPue5hVuhLd8fEU/f1vjfeJ+uwzTKdOocTH47jhBmpGd64Yti2va+lhhcJsqKsCawQkZ0BcXxPuOomzHI6ukbg1klkmC6hM4Grk3FtNjffI3QRNx5AKM3Qf5bmX3j46E63XtXjfLnK/XUutoxxbVAzdR48l4awfprRlz36dOofKWCIhfGsHgXNvu5t9Cz5WXcMWFcPQ26c27uPImqVI1w8/BGGx0OfSK07bT0cQlStI2Cew1IArDIrPkji6y9OeT/5eYFJ++L9QCkl1rEQgCCv1TOtojkRS0V3iCofYowJznfc5dWGSI+MVzfsoJknhkB/242uvTTE+X9sHY6+nM2HChNbPjoRGz7Br8QRkY4EVvgT0QogxeDJbV9Y/ng6NTvwN57wGfCOlfLf+8QrgCSmlxryV4B9bFGjOlL360nPlXDoeV4G3FgsAq9Xzy8/lHTG0dNB0MNKmQdP/24OraVZAeEbv1Dh8/h3Ffa9O4P0/rvc549CfvQQTLZ1xaLZY6Df8AsxWK6dOHKfwsLbW7eJbbie+ew9WvvM6laXe8127zHgdiyByVArmKDuuomqPMalb5XeJAHt6LLXHK1RnHLZ0dI6vvbaUM+XztaMx9no6rRpb1BQpZQ2QBWQJIWLwiPR9sQkYKIRIB04At+IR+DdlPp7A7l0hRCKe8uRBf/Zk0HXQ8t6qWLUK6lxUZ2drB2BCcPaWzVQsWRIQ24dQQbWM+L89lBRUEh5to+i4g73f5KM0+8UoJbicChdcl05Cjyi+ytyrquuKivd4GbVUq9XZHYe+0NJqleTnEZOUzKp3X/fWarlc5GxcT0xSCvE9emILD6dWRTsYnZjEhVNu8VxTVxf6HYdlNVgTIyj9bL+6pcMGz3gdc6xNPQADkJA0NUMzwDLE7gZnOn4FYU2RUpYDPsX5UkqXEGIasASP3uttKeVOIUSDwH9B/XNXCCF2AW7gMSml91BEg5BGL8slpaTwX8+pem9VLFqMtXdvIkaNwvHVVyjl3q32lrQ0TDZbl7N9AG3vLSkl6+cdUJ2BuHmRpxU/LMrqFYA14KpTGHVNuudrpzsgtg/Bgp5gvqbSwerZb6lqtTZkfehjZcG9L7/VeI9g6Tj0hZ4gPuK8JNzlTsq+OKjecfilb1uH7n+9CJPNrGtMCkaAZWCgRYuDsJYgpVwELGp2bEaTryXwSP1/Bl0QzSzX6jVIZw3V277DXawRdwvBgKVLVNeBrmv70PC8VldiVXmtqmlpA7985mIiYm26pcQGurrtw+JXZ/HtZ1k4Kx04Tun/fXfnzNfJ+tufNMbvJDZ+HUyCeF9ZLk1B/Cf7vEuMKiRPG0bx7F24VbKl5jg7JpsZ8N83ywiwDIKF7OxsVqxYQVlZGdu2beOyyy4jIyOjw/ehG4QJIUzAhVLK9R20H4MQRNcA9YUX1LNcCxdi7d2bqLFjqVi9GqWszGvdpsOoQ832QQ+tQdRSSpL7xlB4pII1H+71ynQ1dCUOGpPGga2FOKvU3eMj67MPoWb74Astb60T+3ZjD49g66IFuOpODxak201J7gkGXTSOhF592PzFPKrLvd9r0YlJxHfv4dcQaQiOjkOtGYc1+0sw2y3UnaxSzU4BoEgix6RhSYqgfPkRFJXu1gZbh5jJgek4NDDoKJoGWLGxsV4BVnZ2Np9//jl1dZ73fVlZGZ9//jlAhwdiukGYlFIRQjwPjOmg/RiEGGoGqHl//BNlX36JUlKKKy9f/cIWZrmg62S6NnzmXUp01Sosf9f3IGrFLZnw80H0GBjXpWwfQDvLJaWkoriIVe+/qeqttX3pIkxms7avluLmqmm/AyA6PiEgWq2OQG3GYencHNyVtbpareothQibCUtShOacQ3OcnbjrPO8VYTcb43UMQgq9IEstwFqwYAH5+fl069aNkpISNm7ciKtZI1ddXR0rVqwIriCsnqVCiB8Dc6U/rZQGZxSFL8xUzXRVrlhJ2HkZmKKiUBwOr+u6apYLtEXzJ49XYLGZVUuEDUy84xyS+0TzxcvbNQ1OIbQGTUPrzE0XvzKLDXM/oqqsBGdlpe76D7yfxVsPTtX11YKOnXHoC71SolQkZYvVzUvLvzjkc+3uf7kIIUTABPFGKdGgo2hNFmvBggUUFxcTHx/PokWLGp9rwOVysX69p6BnNptxa/zBVqZSkWlv/AnCHgEiAbcQohoQeORcMe26M4OgoLmoPumhh4jIGIpj3Toq163HlZenfqEQpH/00RmX5QLYMF9dNP/dsmMIASazUBXNR8XbOeciT3Dqr8FpMARYvtAyN3VWVxGXkkbh4YOfWfKqAAAgAElEQVRs+DTTK8slFTdlhfkMGT+JpD792JD1IVVl3j5v0YlJmC3WFpcS27s5o6WDpks+2YdjQy7UKdSdrAaXtl4r6dcZFGfuQdHQajWM0DIE8QbBRGvLhG63m549e1JSUqIZZK1Zs8bn/R955BGioqJ48cUXVQOu2NjYNn6HLcefAd7RHbERg+BDVVTfZJi1tWdPREQEsqrK69qWDqsOFbSyXAVHyzGbTeQfLFPNYDVwz8xLOLy9qOuWEotOsu+T907LLn09532VjkQnK9561ee6itvN5fdOA8AeHh6SpURo0GvlUJdfiTnSSvnyI95lQkVSd6wC+8BuRA2Io2pLAYqK7q/RHd4PrRYYAZZBcOBLh1VVVcXSpUu9Aqy6ujo+++wzv+4xbdo03n//fcpVOuljY2OJifHkji677LLT9gJgtVq57LLLWvW9tQW/uiOFENcDl9Q/XC2l/KL9tmTQkWjZR9Tl5ZH/f3/znrUoJabYWNI/+Rhb795nXNeimp7LXaeQveI4JrMgqXc01jAzdTXe6e6oeDu2MEuLS4mh6L315WsvsnvdGly1taolwgZuevLvJPVNZ/bjD7SslNiJtg+gn+VSalyULfS2fcCl4FhzXH9hCUl3DQHA2j0qIFotA4OOQq/jcMWKFaoB1vz581m0aBE1zX/XNGPKlCl069aNTz75RDPISkxMZNKkST4DrKZ70srKdRQ+gzAhxDPAKOCD+kMPCiHGSimfaNedGbQ7apmu3Ol/oGDmLNy5uZrXKeXl2Hr3Brq+Aeqq/+2hrLgaq81Mbk6prp7r3lmXYLGavdaB0C0lgo5gXlEoyc9jpcqcRMXl4tC2zaT2H4g1LIw6lQ/Y6MQkeg/xfOgFU1dia8xNSz7ZR8XXx5FVLu2OxHrSnryQwn9v0/XVAmPGoUFw0ZpS4vz589mwYQNut1tTb6UoCkOHDqVbt26sXbuWKpXKSmxsbOO9fAVZ/gZYGRkZZGRkdLpnpD+ZsKuBYVJKBUAI8R6wDTCCsBBHTVSPy4Vy8iRJv3uEktmzcRV6ZyeaiuohtAxQ9VDtWqxT2LjAI4SOSQzDYjN5nQOeLJfF6vFMCrVSoh6qWa5XZ/HN/I+pPHUKZ5WeYF7ws7/PDJi5aUegZW4q69xYEyOoy3NQpuK9hSJx5VcRPjQR6+hIHGtPoFSq2z6YI61++WqB0XFo0HG0tOPws88+4+DBg0RERFBcXExOTg6Kcvr/F4qiUFBQwIABAygtLaW21lvDGBsbyzXXXANAVFRUQLJYDQFWKOCvWWsccKr+645Xrhm0CrVSY8y111KTnU35osWaonrpcpF4771YU1P9EtWHEs1d6Edf34/4tEiO7y3RzXL98pmLiYyz+5XlgtDPdKWfP4r8/XtZ8far3lkut5vS/DyGTriclH4DWffRbI05iZ5SYjCZm4K+95aWuWnp3P2+F1YkCT8dBHiCLaOUaBAstLbjsKioiLi4OJYsWeJVSnS73Xz33XeYzWbi4+O9ArAGFEXhtttu87oHtL5MGEpBli/8CcL+AWwTQqzC0xl5CTC9XXdl0GZUS41PTCf/b39HKS0FqxVhtyOd3oHHmSSqX9HEm8tkEiiKetdigwFqqGW5WmMNsejlFwB9NxrF7WbSPfcDYLFa/cp0dYZAvjlq3lslWfuo+q4AXFK3lJjwy3OxdY+k8JXtLSolGrYPBp2JniD+rLPOori4mMWLF6t2HH711Vc+1//jH/+IyWRi5syZuh2HZ2KA5Q+aQZgQ4mIp5TpgLrAajy5MAI9LKTUcOA2ChcKZs7xLjW43srqatL//nehJl+FYs+aMENVXO2o5tvuUVwargbBIC7fOGM2JPSVdKsulZw0R1S2B3Jw9bF34GW5X87KZxB4RyXUPT2fJa7OoKC7yWrul3lsdhZaeS7oV6gqqKFtwwLuU6JY495Zi7RmFsJmQKu8Rc5yd8EHxgH8jesAIsgw6Bl9ZLi1B/Lx58/DH+vOBBx7gvffe0wywTCYT4F/H4ZkWYPmDXibsJWAEsEFKORxY0DFbMmgr1dnZuDSE9bK2lrgpPwK6VqZLa9biNwsOUHHKqZvYqal0ERlrD7ksly98WUOYzBYUt/oMSmd1FX0yhjHup78Ice+tvZQtO4xSXgsu/V84KdPOD5i5qYFBoNDrONTSau3YsQMhBMXFxZqCeCklkyZNIiEhgYULF+JQMdWOjY0lPj7e7wALgqPjMJTQC8LqhBDvAD2EEC81f1JK+UD7bcvAF831Xom/nYbJbObU/z6gJjsbhGj082qKlqg+FNCzj1g/z1tULxVJZVktF1ybTu/BCXz53x1+DbQOlaBLrdQ4cPTF5B/M4cTunbrWELf85Z+k9BvAOw//WtcaIlgE86AtmneXOzFH2dTH+CiglNUSNaY7tp5RlC48hFKhbnAKhrmpQcfSWq1WXl4eUVFRrF69WlWrlZOTQ3JyMsnJyTgcDpwqspPY2FjGjh0LeDJjXanjMJTQC8KuBSYBE4EtHbMdA39Q03vlT/8DALb0dFL+9CeE3UbB3/7eZUT1WiapB7efxFHipFJDy6O4JKOuSQf8H2gdCqiO+fnPCyz+zwuNJQateYrRiUn0HHQu4J81RDB4b4G2aL588WH9hd2SuGv7ec6X+JXpMgIsg/ZGT6s1aNAgioqKNLVaGzZs8Ln+fffdp3of6Podh6GEZhAmpSwC5gghdkspt3fgngx8UDhTxVoCMMfH02/hF4j6Gr0pLKxLlBpB2yT1wNaTJPeJxhZuprZa3SC1gVArN6q50KcPH8WJPbtY/tYr3mN+pMQWHs5V0x6l+1mDOLJ9a8hbQ9QVVGKym6k9WqErmk95eDhF7+wMiPeWgUGg0Mt0tVWr9fjjj/Paa6/5HL9jCOKDG3/GFhkBWCfQUG5Mzs0lp94ANWrCRMq/+BxXrrq1hLukpDEAg65RanTVuTm265SufcRN00e12DoiFF3oF/3nBdUSc1Nqa2oYMHI0EFzWEK3NcjlWexzmLUnhCKvJu9yIJ8iypkQa3lsGHUprzUu3bduGoii6Wq0JEyaQlJTEokWLNLVa4eHhfo/fMQKs4MVfn7BWIYSYDLwImIE3pZTPNHv+l8C/gBP1h16WUr7ZnnsKBZqWGwU/2EtgNkNtLVgs4PIWVDfXe4UKqtYRs3eTvfoYp3KrqHO668fGe1/bkOkK2SxXs+DIVVvLib27WP6Wtz8XUmKLiODGx55k8csvUFGsP+YHgsMaQjPLledAWM3UHinXzXJ1n3EhpgirT9G8IZg36Ci0Sok1NTUkJiZSWFjIypUrvTJdiqJw6NAhevbsidVq9XoePAHWpZdeCnhKj4HQahkEL/6MLTJLKb3rPH5cB/wHuBw4DmwSQiyQUu5qdupHUsppLV2/K6NlLyFsNvrMycR59Bj5M7qOiapaqVFxSQoPV3DO2O70Pz+JqrJa1mTu7RKjgPRc6MsK8nGrfDA3UFtdTa/BQxn3U//G/HQUrTFAdXx1AgRYUyN1rSFMEVbA8N4y6Dh8ZbmWL1+uWkpctGiRX+vfc889hlbLAPAvE7ZfCJEFvKMSQOlxAbBfSnkQQAgxB7gBaMkaZySaTvY1NYQPG0b4sGEIETrWElqlRkWR5O7TdqqXEib8bFDjY5NJhHymC+CrD95Vd6HPy+X8ydfSe8gwlr/5H11/rmDRcoGGAeqn+6jZewrqFP0s11NjMNktfllDgBFkGQSG1tg+bN++HUVRKCwspLJSe1zXHXfcQVJSEm+++WZAzUuNjsOuiT9BWAZwK/CmEMIEvA3MkVJ6jzE/nR7AsSaPjwOjVc77sRDiEmAf8LCU8pjKOWcMitOJCAtDVld7Pde03Bgqei+trsZ9m/IpOl6p2dUIp4vqIbQzXUtee4lda1dTUXQSR0mx6nWKojD+jnsB/PLnCpquxS9VZim6JNXfncQcH6ar5TLZPR9BRinRoKPQKiU2BEILFy5UtX04cOAAPXr04KyzzmL37t3UqDRHxcbG0q+fpxPXMC818AfhTxdG48meYCkTzyzJLOBpKaXqUDUhxE3AlVLKe+of3w5cIKX8bZNzEgCHlNIphPg1cLOUcqLKWlOBqQApKSkj5syZ4/ee1XA4HERFRbVpjfZAVFQQ9+pr2A4eRJrNiCb2AorNRsXPfkbN6OAVEqu9rvsWKNRVqZ8f1R3i+goUlyRvCzQtegszdB8FcX1N6he3w14DxY7Zb1DrUP8bJbpnH6pO5uNW8e2xRcUw9PapjY+L9+0i99u11DrKsUXF0H30WBLOGtwue9YiKleQ/L3ApIjGY4pJUtZbgoCwEkFYKQiE17USyYHJiuYahUMkju7+f/4EmmD9HFDD2Kv/FBQUcPDgQZxOJ3a7nX79+pGSkgJ4RO8bNmxQHSTtDw2ZqIKCAvbu3XvavESTycTZZ5/deC9fe2kpnf26tgRjr6czYcKELVLKkWrP+aUJA64B7gT6As8DHwDjgEXAWRqXHgd6NXncEzjNxl1K2TQl8F/gn2oLSSnfAN4AGDlypGxrSjYY07rOAwc49qtf4zp5ku6zZiLr6iicOYu63Fys9d2RwZ75av66SkWyc84qzfN/MeOHeHvfudpGrB2x15agVmo8+6JLyN23mwNbNmoGYCCY+vx/vDJl4MlyTfrlvZwzrsmexo+Hqfd16vs175mNuJXTA0aTIuh2WIBJYOsZRV11FdLpLRu1xIU1dh82z6Z1u7IvvTs5yxWMnwNaGHv9AT29VnZ2NuvWrWvMPjmdTvbt24fT6cTtdlNQUKAbgP3mN7/hww8/1CwjNv2+fOnGAo3xHmgfOnuv/pQjc4BVwL+klOubHM+qz4xpsQkYKIRIx9P9eCtwW9MThBBpUsoGAdT1wG7OQCo3bOD4Aw8i7Hb6vP8e4eedB3hKjp39BvGHHzRfCkeWrmPElX2odbrZ9bX66CToWqXGxa/MZOl/X8bldGIyWzBbrari+ujE4NNzgXeAFH1ZbyxxdpwHynzruWxmv0f9GKVFg7aiVUqsqqqiW7dumqXEgwcP0qtXL4YMGcLOnTupVpF7xMbGkpKSYtg+GHQo/gRhd0gp1zY90DDcW290kZTSJYSYBizBY1HxtpRypxDir8BmKeUC4AEhxPWACzgF/LK130go0XTkkCkmBqW8HPuA/vR67TWsPXp09vZahJrma03mPgDSBsTS85xu7N2Qj6tOu6sxlPjqQ29RvVQ8gvTrHn6CPhnDObjl26DRc/lC1T7i0xzPkyYBZgFu75KhOc6OyWYGDANUg8DR2mHUX375pc+17777bgB69+5t2D4YBA3+BGEvAcObHfu3yjEvpJSL8JQsmx6b0eTr6cB0P/YQUjSf69i0lNh85JBSVgYmE91uvyPkAjCADfO97SUAImJtTHl0BADd+8eFdFdj6sCz2b9xAzkb1+M4pS6qr6t1ctaFnjlswZTpUhPVRwxLwnWympp9JZR9eRhc3j8/U6SV1N+PonpXsWGAatAhaHUl7t+/H5PJRH5+vqbBKcBdd91FVlYW5eXecoCWOsgbWS6DjkIzCBNCjAEuApKEEI80eSoGT2bLQAW1uY55T87Aeegw1qRECv71nLcHmKJQ9NprdLv5pk7YcetwVtWx8+tcHCXq5aqqsh90F6FcamzqUp/SbwD2iEicVd7t6aFiklry8V7PoOsafes/pbIOk91sdC0aBAy9LJfD4eDLL79ULSVmZ2cTGRlJamoqdrtdcxh17969mTRpUotKiaEg9zDo2uhlwmxAVP050U2OlwM/ac9NhTJqRquypobiV17RvU7LG6yzae7xNeyy3lSU1LBrbS51NW7MFhNulUxKc81XKLDmg3dUXertkVHc8c+XiElK1hTVd4ZJqp51hHRLyhYe9LaGkHgGWk8ZQNiAbpx8I9uveYtG0GXgi5Z6b82fP5/169dTWVlJRUWF7tqPPvooQgifBqdGKdEg1NAb4L0GWCOEeFdKeaQD9xTS6AVTA1au4PDPf646+zEYRw6p6b3WfuLRCw0clcL5l/emJK/Sr5mNwULzodgjr7kRt8vFnvVfUVlySvUaZ1UlMUmeICRYSo2qWa5Pc3AeKkVWu6nJKdHMdsk6hagLPO83f+ctGhjooSeY1/LeajA+HTJkCGlpaaxdu1bVBDU2NhYhPPYmRinRoKuhV46cJaV8CHhZCOGlzJVSXt+uOwtRLGlpuHK9uwIt3bvXW008fFq5EoJ35JDaOCGAyFgbV9x9LgBJvaMbzw12zZdauXHVe/8FIHXAWdgjo3BWeg/LDcZSo9ooIFwKVRsLMMXYCB+SSM2uYpQq7xmjzbNcDesZ5UYDLdpLMK8oClOmTAEgMjLS6EoMUWprazlw4ABVVR5TyOjoaLZs2dLJu/KPQO41IiKC/v37Y7PZ/L5Grxw5u/7f59q0qzOMpIceJO/3j592rGmQ1SDQD/aRQ+VF1ZrjhCrLTvfZadB8efQVF3fE9lqM21XHqvf+611uBCK7xfOzv70QVKVGUJ/HGD44npp9pbrWEWnTL0AIYYwCMggIalmuBQsWkJeXh91u58SJE7qC+XvuuYePP/44IIJ5g+DkwIEDxMXFcfbZZ2MytY/BdrCjKAr5+flkZ2fTq1cvv0159cqRW+r/XROgPZ4R2Pv2BcAUF4dSVqYaZAXTyKHmmq/hV/ShpKCKnV+d0LwmWPVezTsbx956Bwk9erFzzQp2r1tDTYW6iWplaQkQPKVG0JjH+PFeSsCj6xL1/zbDHGdvLN0YWS4Df9HLdKkNq3a5XGzYsAGApKQkrFar1zngCbJ69uzZYsG8QWhRVVV1Rgdg4JmYkJqaSm5uLllZWdx8880kJSX5vE6vHLkD1Y95D1JK4/8UFSqWLgWLhQFLvsTc5K+8YERN8/XVHI/H1+Bx3UlIi/SyoAhWvZeqiWp9Z6PZamXAyAs5ujOb6nLvv9iblhuDodQopaRskbqoXtjNJP5iMHUlTsrm7zeyXAZtRssaYvPmzVRXV6tmsBqYPn06drvdEMwbnNEBWAMmkwkhBC6Xi6NHj7YtCAOuDdzWzgyklJQvXUbk6NFBH4CBtuYrItbGhJ8NAiAs0hoSeq+v57yv2tkYFhXF3S++SVhUVFCVG71c6i/vgzUpnOqdxdR8X4RS4Z1VAJBON/Z+cdgBYRJGlsvAJ1pZLiklZWVlmtYQx44dY+DAgZSXl2vaQtjtnqy4IZg3CAbmzZvHlClT2L17N4MGDQro2iUlJdx1110cOHCAsLAw3n77bYYMGaJ6rslk8ns+qV450uiIbCHOvXupO3qUhHpn5mBHS/MVrB5fakaqfYeNYOfq5VQUnVS9pqaykrD64aynlRuLThKdmBQ0nY2ln3gykJgE9v6xuKtcyGrfonoj6DLQQ88awuFw4HB4N6I0IKXktttu85nlasDw3jLwl/nbTvCvJXvJLa2me1w4j115Njee33az8szMTEaOHMmcOXN46qmn2r7RJvz9739n2LBhzJs3jz179nD//fezYsWKNq+rV45cK6UcK4So4HQVigCklDKmzXfvYlQsXQomE9GTLvN9cidSW+Pi288Oaj4fjJovrZmN4BkbZLZYcLu8gxatzsbO+kUhFQ3/LsAUYSH10ZGYIqx+i+oNzmz0slynTp1i8eLFmtYQQ4cOpUePHnz11VeqwViDaN4oJRoEkvnbTjB97g6q6zwWOidKq5k+dwdAmwIxh8PBmjVrWLZsGTfddFPAg7Bdu3YxfbpnwM+gQYM4fPgwBQUFfgvwtdDLhI2t/zda6xyD06lYtoyIESOwJCR09lY0ObyjiDWZe3GUOOl5Tjfy95eFxFxHtXKjVBSsYWH89OnnKDpyKGhKjeBdbowYmYysdlO9owjFoV5qVKpcmCKsgDGP0cA3elmu8vLyRrsANRRF4Uc/+hEAYWFhPjNdRinRwF/+8vlOduVq6wi3HS2l1n36H6HVdW5+n5VN5sajqtcM7h7Dn687V/e+8+fPZ9KkSWRkZBAZGcnWrVsZPtx7uuK4ceNUzYGfe+45Jk2apLn+eeedx9y5cxk7diwbN27kyJEjHD9+vP2CsKYIIYYDY/FkwtZKKbe16a5dEOfBQzhz9pPyxz929lYaadr5GBlnJ6qbnYJD5XRLjWDKoyNI6x/r1R0ZjJqvqvIyzXJjndNJUu++JPXuCwRfZyN4yo0Vy4+BgLBzEpCHy3z6d4Exj9FA24W+vLxcVcvVkOXKyMigZ8+erF69WjfLBUamy6BjaR6A+TruL5mZmUydOhWAm2++mczMTNUg7Ouvv27V+k888QQPPvggw4YNY+jQoZx//vlYLH6FULr4XEEIMQO4CZhbf+hdIcQnUsr/a/Pdgwy9wdu+qFi6FIDoy7Uj6Y6keedjZamTylIn6cMSufLuIZitnk6WYNF8qQ7OHnAWWxZ+xs7VyzWvC7bORleZ0zObUaXcaI6xkXjHYKPUaOAXapmuefPmsXjxYqqrqzWvUxSFG2+8EQCbzWZYQxh0KL4yVhc/s5ITpd7v3x5x4Xz0qzGtumdxcTEbN25k7lxPmHLLLbdw6aWX8uyzzzZa9jTQ2kxYTEwM77zzDuDRS6anp5Oent6q/TbFnzDup8D5UsoaACHEM8BWoEsFYVqDtwG/ArGKpUsJOy8Da2rnBzSg3fl48mhFYwAWLGjpvRq0XoMvmUhcag82ZH0YFOVGr87Gib0RZkHVtkKcB0o1jV3c9Q0Phn+XAWjruVwuF7m5uSxatMgr0yWlpK6ujiuvvJJ169YZWS6DkOOxK88+TRMGEG4189iVZ7d6zaysLK6++urGbt309HRSU1NZu3Yt48aNO+3c1mbCSktLiYiIwGaz8eabb3LJJZcQE9N2abw/QdhhIAxomLNjBw60+c5Bhtbg7cKZs3wGYbXHj1OzaxfJjz3anltsEVqdj1rHOxMtvZctPIK7Zr1OZFw3AKLj4zu93Kja2TjXM0/THB9G9MTeVG7KRyn3bk82OhsNGtDSc61Zs4aysjJcKk0mDbhcLsaMGWOM+TEISRrE94HsjszMzCQ7O5u+9Wbp4MmOffjhh15BWGvZvXs3d9xxB2azmcGDB/PWW28FZF297sh/4/mb3gnsFEIsq398ObA2IHcPIrQGb+sN5G6gYpmnXBZ9xRUB3VNrkFKyY/VxzeeDrfNRSqmp96qtqW4MwCA4yo1liw+pdzZGWUl9bCRCCCyJ4Ua50UAz01VdXa2p5yotLWXUqFH06dOHxYsX6476MbJcBqHKjef3CIglRQOrV68O2FpajBkzhpycnICvq5cJ21z/7xZgXpPjq/1dXAgxGXgRMANvSimf0TjvJ8AnwCgp5Wa1c9obzcHbaWk+r61YuhT7Oedg69WrPbbmN7XVLlbO3sOBrYUk9oykpKAad5B2PkopOfzdFtZ/8oHmOc3tJTqC5qXGmCv7EjE0kerdxVRuKlDNcAEojjpjXJBBI1qZruXLl+s60LvdbiZPngx4BmAbXYsGBl0bPYuK99qysBDCDPwHT+bsOLBJCLFASrmr2XnRwAPAt225X1tJfvih0zRhAJjNjYO3tagrKKR62zYSH/htO+/wdJp3NQ65pAd7NuRTVljFmB/15/zLe5OzqSAoOh+bi+4HXXQJx3d/T17OXmKSUhgy8Ur2rF3d6XovtVJjySf7KJmXA7UK5lg7IsyMrHF7XavV2WjQNdGbtaiX6aqsrGT8+PFs2rSJyspKr3UNPZeBwZmFP92RA4F/AIPxaMMAkFL283HpBcB+KeXB+nXmADcAu5qd9zTwLNCpgqoG3VdDd6QpMhLF4cAcF6d7XcXyZQDEdGApUm3m4zfzD2INM3PDw+fT4yxPCS8YOh/VRPebFnyKPTKay++dxrnjL8NssdJ78JBO13uVLznsXWpUJEhBwp3nEjawG1XbTxqlxjMcrVmL2dnZVFZWkqcjYXC73YwfP574+HjDhd7AwMAvYf47wJ+BmcAE4E48rvm+6AEca/L4ODC66QlCiPOBXlLKL4QQna5qj73uusZgTKmt5dCNPyLvz3+m/+efY4qMVL2mYtlybP36YR8woMP2qdX5aAuzNAZgwYLqTEfAFhZGxqTJjY87W+/lrqjFXarRtFCnEH52PGCUGs8E9LJcAMuXL1edtbh//3769OnjV6bLyHIZGBgACCk1+ukbThBii5RyhBBih5RyaP2xr6WUui0HQoibgCullPfUP74duEBK+dv6xyZgJfBLKeVhIcRq4FE1TZgQYiowFSAlJWXEnDlzWvp9nobD4SCqfp6gHtb9B+j2/PNUjx9PxS03ez0vHA6Sfv84lVdeQeUNN7RpT1qo7XXnHG1Tu3Nv7Tz7ieZ7dTlr2P72y5rnj/hNx8fdUbmChH0CSw24wqC8h8RWBVH5AiHV/7aoC5McGd82I8G24O/7NRgI9b0WFBSwd+9eFOWHn7fJZKJXr16YTCZKS0spKSnRXLMhW6W1ztlnn90qh+1Qf12DFWOvgSE6OpoRI0Z09jaCgi1btpCVlUW/fv0YOHAgABMmTNgipRypdr4/mbCa+oApRwgxDTgB+PNn/3GgqVK9J9BU+R4NDAFW1wuaU4EFQojrmwdiUso3gDcARo4cKdualvc7tT9+PPm5uZRkZjL4V1MJHzbstKdLs7LIUxSG3nsvYYMHt2lPLdnrkaXrVK0mouLtjB9/cbvswx8a9qq43Wxfvpj1H+uI7hOTOry8UrmtkNIVP5QSrTWQcECAWRA1Jg1TnI2KZUe9So3JNwwkvRMzXaFUigr1vc6cOfO0wAk8Wq4jR44AkJycjM1mo7bWu0EjNjb2tPV8ZdTautdgxdhr+xDMe92yZUtnbyGo6N69O0OGDGHMGN/ms/4EYQ8BEXjE808DE4Ff+HHdJmCgECIdT+B2K3Bbw5NSyjKgsf1NLxPWmSQ98ggVq1aR9+STpH/6KcJma3yufPm3Sr0AACAASURBVOlSrD16YD/nnI7dU+9oryCsMzsfG4X3RSfZ/cF/EWYzlSWn6DV4KL2HDuPbeR93uugeoPxLdXsJc5SVuOs9r5052m6UGrs4aqOABg4cyKFDhygrK9O87ne/+x3R0dFemjAw/LkMDIKBefPmMWXKFHbv3s2gQYMCuvbq1au54YYbGl3yp0yZwowZM9q8rs8gTEq5CRrLhw9IKb39/tWvc9Vnzpbgsah4W0q5UwjxV2CzlHJBG/bdYZijIkl76s8c+9WvKXrjvyRNux8Ad3k5lRu+If7nP/cai9CeZK86zqHviug+MJby4pqg6HxsKryvKvf8Eht+1fWM/8W9CCGITUruVNG9u8xJxdoTjY713s//cNzoauzaaI0C8iXLiI2NJTo6GjD0XAYGbSb7Y1jxVyg7DrE94bIZkOEt+WkpmZmZjBw5kjlz5vDUU0+1fZ/NGDduHF988UVA1/SnO3IkHnF+dP3jMuAuKaXP/KOUchGwqNkx1dBRSjnej/12ClGXXkrMtddS9PrrxFx5BfaBA3GsWQN1dURfcXmH7SNncwFff7yP9PMSmTx1CCZz548f0hLe52zawIRfeoapdpTovrnHV+SYNFyF1VR9VwiKRFhN6pmwuOAysDVoPXolwPLychYvXqw6Cshut3PbbbdRUlLCwoULjSyXgUF7kf0xfP4A1NXPjyw75nkMbQrEHA4Ha9asYdmyZdx0003tEoS1B/6UI98G7pNSfg0ghBiLJyg7oz6BUv4wncq1a8n705P0+fADKpYuxZKcTPh553XI/Y/tOsXyd3aR1j+WK+4+NygCsKKjhzXd7iuKizp0L2oeX+WLD4MJIkenET2uJ84j5Ya9RBdGyzpix44dlJWVUVhYqHmt0+mkT58+9OnTB5PJZGS5DAxay+InIH+H9vPHN4G72R/uddXw2TTYomFPmjoUrlL1em9k/vz5TJo0iYyMDCIjI9m6dSvDhw/3Oq+1A7wBNmzYwHnnnUf37t157rnnOPdc/WHl/uBPEFbREIABSCnXCiH8Kkl2JSzx8aT88Q/kPvZ79l04BqWiAlNEBOULF/o14LstFBwuZ9HrO+iWGsk192VgsZnb9X6+cLtcbPosiw2fzkEIoVrK6Wi3e1WPL8AUbaPbDR77EEt8WOO5rtIaLHFhhuarC7FixQpV64icnBzS09O5/PLL2bBhg19Dr42gy8CgnWgegPk67ieZmZlMneqpvtx8881kZmaqBmGtHeA9fPhwjhw5QlRUFIsWLeLGG28MyBgjvdmRDbvfKIR4HcjEMzvyFlowuqgrISVgMqHUR9FKVRV5T3qqq4EOxH5wxFfYKTZjj7Bw3QPnYY+wBvQ+vmjudp9x2WT2fbuOk4cPcvaYcfQcPJQ1s9/qVOG982i5pseX0kwH1qD58nQaXdAR2zMIIM3LjRMnTiQ+Pp59+/bpiup/8QtPL1F0dLRfonoDA4NW4iNjxcwhnhJkc2J7wZ0LW3XL4uJiNm7cyNy5cwG45ZZbuPTSS3n22We9NNutzYTFxMQ0fn311Vdz3333UVRURGJi2xIOepmw55s9/nOTr/VVrF2Uk7NmQbP2dVlTQ+HMWQENwpo74iPBVatwYk9Jh4rv1dzu1300G2t4ONf/7g8MvOAiAOzh4Y3dkdGJSe0mvG+u+YoYlULd0Qpq9pZ47INV3pWG3qvroCWqBxBCYDabcbu9R0oZo4AMDIKIy2acrgkDsIZ7jreSrKwsrr76aux2z+d9eno6qamprF27lnHjTrc0bW0mLD8/n5SUFIQQbNy4EUVRSEhIaPWeG9CbHdl59uVBiktjHInW8dai5ojvrlPY8NmBDg3CtET39ojIxgAMfhDet6ePjZrmq2LZUbAKYib3xRRhpezzA4beK4TRE9WXlJSwaNEir3IjQHh4OA888AA5OTnGKCADg2CnQXwfwO7IzMxMsrOz6du3b+Ox4uJiPvzwQ68grLVkZWXx6quvYrFYCA8PZ86cOQFxRvCnOzIWTxbskvpDa4C/1vt8nVFY0tJw5eaqHg8kakasesfbCy1xveNUcYfuA7Q1X+YIKzHjPZ7AwmoyPL5CFLUs14IFC9i5cyclJSW6ovrq6mrCw8ONLJeBQaiQcXNALCkaWL16dcDW0mLatGlMmzYt4Ov62x35PdDwit2OpztySsB3E+QkP/wQeU/OQNbUNB4TYWEkP/xQQO9jC7dQW+3yOh4V33GlNberDqs9jLqaaq/nOlp0r1TVaWq+DI+vroGaqN7lcrF371769OnDFVdcwYYNG1S1HIao3sDAIFTxJwjrL6X8cZPHfxFCfNdeGwpmGnRfhTNn4crLw5KWRvLDDwVUD3ZkZzG11S6ECWSTxE9HOuI7Sk7x+cxnqKupRpjNyCY6m44U3Uu3guObPCpWHNU8x9B8hQZapUan08n+/ft1RfV33nknAFFRUYao3sDAoEvhTxBWLYQYK6VcCyCEuBjwTo+cIcRed127WVKUnaxi2Vs7SegRRcbEnmxaeKjDHfFP7NnF5zP/gbO6imseeAypKB3idt9cdB82JAHnnhJcRdXYB8Rh6x+LY+UxQ/MVgmj5d61fv56ioiJcLpem1YkhqjcwMOjK+BOE/Rp4v14bBlCCf7MjDVpAndPN4tc8BndX/XoosUnhDL64e714uP2Gcje1oLBHROKsqiQuJZUf//Fpknr3BWh3t3s10X3l2lxEtJWEXwwmbFA8QggscWGG5isE0fLvKigoYNSoUZxzzjmUlZUZTvUGBgZnHLpBWP28yLOllOcJIWIApJTlHbKzMwgpJSvf382p3Equ/e15xCaFd8h9m1tQOCsdCGFi1HU/bgzAOgJNo1WzifBzfmgBNjRfwYvaUOx+/fqxe/duzVKjlJKrr7668bHhVG9gYHCmoRuESSmV+iHcHxvBV/uxbdlR9m8pZMyP+tN7cNt9R/xFzYJCSoVv5n1ExqTJHbIHKaW26F7juEFw4WsotslkQlG8g+ympUYwslwGBgZnHv4MIFwmhHhUCNFLCBHf8F+77+wM4diuU3wz7wD9hydz/hW9O/TenT330VVaQ/F7uzSfN0T3ocHy5cs1h2L/5je/4cYbb8RqPX3SgyGoNzAwCDTz5s1DCMGePXsCvvYHH3zQ+IfiRRddxPbt2wOyrj+asLvq/72/yTEJ9AvIDs5AfhhJ5AQBkbE2Jt4xKCDGb/5SePhgh819bC66j768D7LaRfnSwyAhfFgiNTtPGaL7IEWts/Hss89m79697Nixg/Jy9SS50+kkJSWFlJQUwBDUGxgYeFh4cCEvbn2R/Mp8UiNTeXD4g1zT75o2r5uZmcnIkSOZM2cOTz31VNs32oT09HTWrFlDt27dWLx4MVOnTuXbb79t87o+gzApZXqb72LQiNpIoppKF4e3F3WYG/7x3d8z/9mnsUVE4qqtxV33g9dWoC0o1ET3pVn7QELY2d2Iu2EAlvgwr0DNEN0HB3qjgqSUxMTEYLfbcTq9S8eGf5eBgUFzFh5cyFPrn6LG7fHbzKvM46n1TwG0KRBzOBysWbOGZcuWcdNNNwU8CLvooh+mxFx44YUcP348IOvqDfAeCDwH9Ad2AI9KKU8E5K5nMJ09kujAlo18MfMZopOS+ckf/8qJ3Tvb1YJCVXQvwRRhIeGX5zZm/wzRfXCi1tkopcRms/Gzn/2MXr168f333xv+XQYGBgD8c+M/2XNKuxyYfTKbWqX2tGM17hpmrJtB1r4s1WsGxQ/i8Qse173v/PnzmTRpEhkZGURGRrJ161aGDx/udV5rB3g35a233uKqq67y61xf6GXC3gbeB74Crgf+TQtd8oUQk4EXATPwppTymWbP/xpPmdMNOICpUkptkVAXoDNHEu1cs4Ilr71Ict/+TJn+FBExscSMS25XCwotcb1S5erQ8quBNmrlxrS0NLKzszU7G2tra+nTpw9g+HcZGBj4T/MAzNdxf8nMzGTq1KkA3HzzzWRmZqoGYa0d4N3AqlWreOutt1i7dm2b1mlALwiLllL+t/7rfwkhtrZkYSGEGfgPcDlwHNgkhFjQLMj6UEr5Wv351wMvAB3TltdJRMXbVQOu9hhJ5OUBVumg95AMbnj0T9jCIwJ+v+ZIKRHhFqTKCCZDdB8c6HU2CiGwWCy4XN4/P63ORmMotoHBmY2vjNUVWVeQV5nndTwtMo13Jr/TqnsWFxezceNG5s6dC8Att9zCpZdeyrPPPuv1x35bMmHZ2dncc889LF68mISEwDgZ6AVhYUKI84GG7yC86WMppa+g7AJgv5TyIIAQYg5wA9AYhDWzvYjEI/jv0oy5oT8r3t+N4v7hW22PkUSqHmAmE+eMndghAZjbUUtJVo4nABOc9pM1RPfBg1a5MSwsjPvvv59Dhw4ZpUYDA4OA8eDwB0/ThAGEmcN4cPiDrV4zKyuLq6++Grvd88d9eno6qamprF27lnHjxp12bmszYUePHmXKlCnMnj2bs846q9V7bY5Q644DEEKs0rlOSikn6i4sxE+AyVLKe+of3w6MllJOa3be/cAjgA2YKKXMUVlrKjAVICUlZcScOXP0bu0Th8NBVFRUm9ZoC3sXKLhrPLMhrRGQnAFxfdXdQlq71x2z36DW4d21ZouKYejtU1u8nj807DXiJCTvMGFyQfHZErcFEnIElhpwhUHxWRJH986Ntzv7PdAS2rLXgoICDh48iNPpxG63069fP1JSUnA4HOTl5XHihLbMsyGjpbVGoPfa0Rh7bR+MvbYPwbzX6OhoRowY4ff5ge6OHD9+PNnZ2cTExDQeKy4u5uc//zmvvvpqq9dtyj333MOnn37aKMOwWCxs3rzZ67wtW7aQlZVFv379GDhwIAATJkzYIqUcqbauZhDWVoQQNwFXNgvCLpBS/lbj/Nvqz9cdiTRy5Eip9o23hM4smZQXVTP7Txu4aMoAv3zBWrvX52+9DtR+tkLwuzmft3g9PRo6G12lNZjsFqTTjSUlgoSfDsKaGhnQewWKUCqbtXavzUuN4DFOjY6OpqysDLPZjMlk8sqEgafc+PDDD3fYXjsDY6/tg7HX9iGY97ply5YWBWFdmS1btrB+/XpGjhzJmDFjABBCaAZh/viEtZbjQK8mj3sCuTrnzwECE7IGMQe/8xik9js/sF5czYmMjaOytMTreHt4gDVYUAgE0ukGE0SN6xG0AdiZglqpUVEUKioquOqqqxg6dCj79+83yo0GBgYGnYQ/jvmtZRMwUAiRLoSwAbcCC5qeUG+D0cA1gFcpsqtx8LuTJPSIIjap/XRZzqoqVRPWQHuAgYYFhQIVy48G9D4GLaOiokKzs1FRFEaPHk1ERAQZGRlcd911jUL72NhYrrvuOqOz0cDAwKADaLdMmJTSVT93cgkei4q3pZQ7hRB/BTZLKRcA04QQk4A6oATQLUWGOlXlteQdKGPUNe3nfyulZMmrs6iuKOfCKbew86uV7eYBZsx97FyaW0tMnDiRyMhItmzZwt69ezWvM2Y2GhgYGAQHfgVhQogeQJ+m50spv/J1nZRyEbCo2bEZTb5ufTtECHJo+0mQ0P/8pHa7x5Yv5pGzcT2X/vwuRl43hYtvub1d7iPrFErmaicuDQuK9kXPyf7/27v3+KirM/HjnyeTC+ZGCPcQJCTcVASEgNIWgYpoUbCWcrNVa3WprlZt11/X3d78ueuupdvV7drdX1ltvTKppYDQquBWQFAkkARBIdwiYCDcBkIyCclkZs7vj5mESTKTTObCDOR5v168yHznfM88+UJmnpxzvudJTU3lhhtuIC0tjQ0bNuhUo1JKxalOkzAR+QWwAM/WEi7vYYNnE1fVBRVlp8jsewXZOdFZK1W5+1M+WPYyw6//EhNuvzMqrwHgqnVge203jiO19Bjdm8a9Z7Xu40Xmb70XeBKwH/7whyQmen60MzIydBNVpZSKU8GMhH0dGGmM0fmlMDTWN1FZfpaxNw2Oyk7x9rNnWPP8s2QNyOGWBx+P2m70jmN2bK/sxl3fRPa3riL12j6t7o5MzOqhdR8jxHe6saysrKVwdkc72dfX17ckYKBTjUopFc+CScIqgCRAk7AwHNplw+025EdhKtLldPLn55/F0XCeeT99hpTUyC369y2snZCWiLvBiSUtmb4PjiV5kGfPmua6j55bqCdF7LW7M3/TjatWrUJEcLlcJCQk4Ha7253Xdr2XUkp1FytXruQb3/gGe/bsYdSoURHtu7y8nPvuu4/S0lKeeeYZnnjiiYj0G0wSVg/sEJG/4pOIGWMejUgE3UTFjlOk9Uymf15m542D4FuSKLlHDxznzzPr+0/QZ/CQiPQPrbefAHDXeXa/T582uCUBU9ERaHuJpKQkvvOd73D27FndWkIpdUk6t2YNJ597HmdVFYkDB9LvB4/Tc/bssPu1Wq0UFhZSVFTEU089FX6gPrKzs/n1r3/NqlWrItpvMFtUrAb+CfgIKPH5o4LU5HBx5FMbQ8f1RRLCnyZsLklUe/oUGIPj/HkkweJ/c9Yw+N1+woD9g8qIvo5qzeFwBJxubGpqYvDgwbq1hFLqknRuzRqqfvoznMeOgTE4jx2j6qc/49ya8DYRt9vtbNy4kZdeegmr1RqhaC/o168fEydOJCkpKaL9djoSZox5JaKv2A198dkZnE3uiE1Fbip6taUmZDPjdrGp6NWIbkGh209ET9vtJW666SaGDBlCcXExJSWBf8fxnW7U9V5KqXhz/F/+hcY95QGfP//JJxiHo9Ux09BA1Y9/QvWbf/R7TspVoxjwj//Y4euuWrWKGTNmMGbMGNLS0igtLWX8+PHt2oVTwDsaAiZhIvKmMWa+iOzCT2FtY4y++wepYscpUtISyRmeFZH+am2nu3Q8FMblRpIS2o+EodtPhCvQ9hLGGESEq666ir59+/LRRx/pdKNS6rLSNgHr7HiwrFYrixd76iLPnz8fq9XqNwkLtYB3tHQ0Eta8h9ftFyOQy5XL6ebQrtMMHdsHiyUyBQoyevfxTEX6OR4JxunGtqzck4AlCLgv5OC6/UT4/K33MsaQnJzMQw89RK9evQDo3bu3bi+hlLqkdDZitf+rN3mmIttIzMlhyGuvhvSaNpuN4uJiVqxYAcCCBQuYOnUqS5YsabdTwCUzEgYsEJEPgTJjjPNiBXS5ObrvLI31TvLHRe6uyIIJk9ix9i+tjkWqJJFpcmN7fTcNe8+SNTsfSU1quTvSkpWi20+Eyel0Blzv5XA4WhIwuDDdGM+Fe5VSqiv6/eBxqn76M0xDQ8sx6dGDfj94POQ+ly9fzqxZs0hJ8czSDB06lAEDBrB582amTJnSqu2lNBKWC/wHMEpEduJZmP8hsMUYc+ZiBHc5qCg7RWKKhcFXZUekv7NVR/ls4/tkDcjB5WyKaEkit8OF7dXdNB6sJuvOYaRfPxBAk64QtF3zNXXqVBobG9myZUvAc3R7CaXU5a75LshI3h1ptVrZuXMneXl5LcdsNhvLli1rl4SF6vjx4xQWFlJTU0NCQgLPP/88u3fvJjMzvB0PAiZhxpgnALzFtwuBLwHfBf5HRKqNMVeH9crdgNttqPjkNEOu6U1isiXs/pwOB2ue/wWWxETm/fQZMvuEP7rmuw8YFgGXode8EaRN6B92392VvzVfq1d7atcPGTKE0aNHs23bNl3vpZTqlnrOnh2RLSmabdiwIWJ9BTJgwAAqKyO/M0Aw+4RdAWQCPb1/jgG7Ih7JZehExTnO1zgiVityw6svcupQBXf+/c8jloD57gOGy3gSsQhso9GdBSoplJaWxn333Qd4fqB1vZdSSnVvHd0duRS4BqgFtuKZjvx3Y8zZixTbJe/gjlMkJApDRvcOu6+9WzbxyXtvUzj7G+SPnxiB6ALsA+Yy1Kw9pFOQIaqurg645quurq7la91eQimlVEcjYVcCKcB+4ChQCVRfjKAuB8YYKspOMXhUNslXBDPgGFj18SrW/fbXDBwxiq9EYPF9M90HLDT+9vgaPHgwmzdvpqysLOB5uuZLKaWUr47WhN0qnns7r8GzHuzvgNEicgbP4vyfX6QYL0mnv7BTa2ugcFZeWP24XU7WPP8sCQkWbn/sR1gSw0vofEmKBdPoandc9wELrKM9viwWCxMmTGjZWkLXfCmllOpIh5/oxhgDfCoi1cA575/bgUlAp0mYiNyK5w5LC/CiMebZNs//EHgAcAKngO8aYw6H8H3ElX1bj7PRuheA4jWfk5iYwIjrB3Spj5bakN79wCbc/nUy+0RuirB+5ylPApYA+MxI6j5gHetoj6+HH364ZbQrNTVV13wppZTqUEdrwh7FMwL2ZaAJ7/YUwO8IYmG+iFiA3wA345nK3CYiq40xu32alQGFxph6EXkIWAIsCPF7iQv7th5n/RvlOB2ezKauupH1b3hKOASbiDXXhvQtTfTJunfon1cQkbJEjqN2zv5xH8lDMkmd2J/a/z2i+4AFqaM9vrSkkFJKqa7oaAv3PGA5MMkYk2+MudsY81/GmE+MMe1r2bQ3CThgjKkwxjiAIuAO3wbGmPXGmHrvw4/x7E12Sdvy1sGWBKyZ0+Fmy1sHg+7DX21Ip6ORTUWh7Sbsy2V3YHt1NwmpifT+9lWkFw5g4JOTyH12CgOfnKQJWAB1dXWsXbs24PO63ksppWJr5cqViAjl5YFrV4bKGMOjjz7KsGHDGDNmDKWlpRHpt6M1YT8Ms+9BwBc+jyuB6ztofz/wTpivGXP2M/4XtQc67k+0akMapxvb63tw1TXR78ExWDKSw+rvctR20f2NN95ITU0NW7ZsoampiSuvvJJjx47hdF4oIqHrvZRSKnj7th5ny1sHsZ9pJD07hcl3FHR5yY4/VquVwsJCioqKeOqpp8IP1Mc777zD/v372b9/P1u3buWhhx5i69atYfcrnmVfkSci84BbjDEPeB/fjWdU7ft+2n4beASYaoxpl62IyGJgMUD//v0nFBUVhRWb3W4nPT09rD4C2bvajbO+/fGkVBgxJ7jakbteW4rDXtPueHJ6JtfevTi0wAz0/UzoWZnA8TFu7DmR/3eP5nWNNH+xnjhxgr179+J2tx/o7du3L3l5eaSlpXHixAkqKipobGwkJSWF/Px8+veP3ua2l/p1jVcaa3RorNERz7FmZGQwYcKEoNq2XbIDkJicwPRvjQorEbPb7RQUFPDee+8xb9489u7dG3Jf/nzve99j2rRpLFq0CICRI0eyYcMGBg4c2KpdSUkJy5cvJz8/n+HDhwMwffr0EmNMob9+I3erXXuVwGCfx7l4NnptRURmAD8mQAIGYIxZCiwFKCwsNOHW0YtmLb60+s8pXv15q2OJyQlMWxD8f7D+FsPbL/w7cCFRSkxOYcZ3/oarpkwLKS77lmNUVx4kY1ouubcODamPzlxKNQ79xfrcc8/5TcDS09N5+OGHL1Jk7V3q1zVeaazRobFGRzzHWlJS0vL1pjf3cfoLe8C2Jz4/h8vZehDA6XDz/mt7+Gxz+8LeAH0GpzNl/ogOY1i1ahUzZsxgzJgxpKWlUVpayvjx49u1C7WA99GjRxk8+EJKk5uby9GjR9slYQA5OTmMHj2ayZMndxgzRDcJ2wYMF5GhePYZWwjc5dtARK4Dfgvcaow5GcVYLhpHvRME0rJSqDsb2lBr/4LhgKFHWjoNdXYy+vQNqTZkq5JEQOLANDJn5nWpj+4k0KJ7uz3wG4pSSqngtU3AOjseLKvVyuLFnpmi+fPnY7Va/SZhoRbw9jdr6NnFKzxRS8KMMU4ReQRYi2eLit8ZYz4TkaeB7caY1cAvgXTgj95v5ogxZk60Yoo24zbs336SvGv7cNvfhn5n3MHtnnnmu5f8J6WffhbSbz/tShIBrtPnqf/klC6+b+PEiROsW7cu4PO66F4ppYLT2YjVK//4od810unZKdz5d+2TpmDYbDaKi4tZsWIFAAsWLGDq1KksWbKkXaIU6khYbm4uX3xxYZl7ZWUlOTk5IcXrK5ojYRhj3gbebnPsZz5fB/6OL0HHDlRTV93Il+YWhNXPwZKt9MsrCKs+pL+SRKbJ3e1LEvkuvC8pKSE7O5sjR46QkpLCtddeS3l5uW6yqpRSUTL5jgK/a8Im3xH65+by5cuZNWsWKSmejcaHDh3KgAED2Lx5M1OmTGnVNtSRsDlz5vDCCy+wcOFCtm7dSs+ePf1ORXZVVJOw7mb/thMkJicwdEzoyVN9zTmO7S3n+m+Et12aliRqr+1u97W1tdTW1lJQUMDcuXNJTU31W5JI9/tSSqnIaF6aE8m7I61WKzt37iQvL6/lmM1mY9myZe2SsFDNmjWLt99+m2HDhpGamsrvf//7iPSrSViEuFxuDpaeYuiYPiSlWELu5/Oy7RjjZlhhR7t5dC4hLRF3nbPd8e5cksjfbvcAp0+fJjU1FdBNVpVSKtpGXD8gIltSNNuwYUPE+gpERPjNb34T8X6D2zNBdeqL3WdoqGti+MTwtio4WLKV9F7Z9Bsa+tCsq6YRd1P7mpDduSTR8ePHAy68D3RcKaWUiiYdCYuQ/dtPkJKayJVX9w65D2dTE4c+KeOqr0wN+a4L4zacKdqLGCHja0Oo21LVrUsS1dfXs379erZv346I+L3DRRfeK6WUigVNwiKgyeHi8x2nGVbYD0tS6IOLlZ/tpKnhPAVhTEXWbvyCxopz9Jo7nLSJA8icOrjzky4Tbddz5efnU15eTkNDAxMnTqRfv36sXbtWF94rpZSKC5qERcDhXTaaGl1hT0UeKCkmMSWFK68ZG9L5jYdrqHnvMFeM7UtqYfR2cI9HbRfdnzt3jrKyMrKzs7n33nsZMMCz/iA5OVkX3iullIoLmoRFwP5tJ0jNTGbQiF4h92GMoaKkmLwx15GY3PWaju7zTs5Yy7H0TKHXncMisoncpSTQonuXy9WSgMGFhffxvPu0Ukqp7kEX5oepsb6JVnz7bQAAH3NJREFUw5/aGFbYj4SE0BOfU4c/p9Z2ioIJXZ+KNMZwduV+XDWNZC8aRUKP7pVbG2N00b1SSqlLjiZhYarYcQqX0x3+XZHbt4II+eMnBtW+ruwkVc8WU/nkJqqe/pjzO0+TOTOPlCszw4rjUmOz2XjttdcCPq+L7pVSqntYuXIlIkJ5eXlU+v/xj3/M4MGDI1pIvXsNmUTB/m0nyOzTg/554SU/B0u2kjN8FKk9szpt27Ykkfu8p15lQkbXpzEvJW0X3g8aNIh9+/ZhsVgYO3Ysu3fv1kX3SikV5/ZsWs+moleptZ0mo3efkGoj+2O1WiksLKSoqIinnnoq/EDbmD17No888gjDhw+PWJ86EhaG+hoHleVnGV7YP6w1WLVnTnOi4gD5EyYF1d5fSSIM1L53OOQY4l3zwvvm6cVz586xe/du+vXrx8MPP8ydd97J7NmzW0a+evbsyezZs3XRvVJKxZE9m9azbukL1J4+BcZQe/oU65a+wJ5N68Pq1263s3HjRl566SWsVmuEom3thhtuiEipIl86EhaGAyUnMYawpyIrSrYBBL1LfncsSRRo4X1dXR2ZmZ5RSN3tXimlYmv9y0s5ebgi4PNV+/bicrZ+L3c6Gln7/37NzvfX+j2n35B8pn9ncYevu2rVKmbMmMGYMWNIS0ujtLSU8ePbFwQPtYB3tGgSFob9206QnZNG70HhzQ8fLNlKVv+BZA8Kbk8vS1aK34Trci5JpAvvlVLq0tc2AevseLCsViuLF3sStfnz52O1Wv0mYaEW8I4WTcJCVGM7z/GKc1x/R35Y/TQ1NHDk008Ye/OsoKc0M2/J4+yf9oHzwu7vl2tJooaGBtatWxfweV14r5RS8aOzEaulD9/nmYpsI6NPXxb8/NmQXtNms1FcXMyKFSsAWLBgAVOnTmXJkiXtPleDHQlzuVxMmDABgDlz5vD000+HFFtnNAkL0YHtJwEYHuamqId2leFqaurS1hRp1/XD/tFRmirtYLhsSxIdOHCA1atXU1tby4gRI6ioqMDpvFCUXBfeK6XUpWXKwntYt/QFnI4LszmJySlMWXhPyH0uX76cWbNmkZLimQ0aOnQoAwYMYPPmzUyZMqVV22BHwiwWCzt27Ag5pmBpEtZF+7YeZ8tbB7GfaSTBIpyoOEfPvleE3N/B7VtJSUtj0Kirgz7HVeug6Wgd6V8eRNbt4Y3ExQvfOx8zMzPp1asXhw8fpk+fPtx///3k5ua2uztSd7tXSqlLS/NdkJG8O9JqtbJz507y8vJajtlsNpYtW9YuCQvHj370I5YtW0Z9fT25ubk88MADYd+FGdUkTERuBf4DsAAvGmOebfP8jcDzwBhgoTFmeTTjCde+rcdZ/0Y5Tod3awiXYf0bnv1IRlw/oKNT/XK7XVSUbmPouEIsicH/U9RtOw5uQ9oNkb1LI1balhyqqamhpqaGESNGMG/ePJKSkgBdeK+UUpeDq6ZMj8iWFM02bNgQsb46smTJEpYsWRLRPqO2RYWIWIDfAF8DrgYWiUjb4Z4jwHeAZdGKI5K2vHWwJQFr5nS42fLWwZD6q9q/j/M15ygIcmsKAOM21G09TsqwLJL6hD4CF08C3fl44sSJlgRMKaWUutxEc5+wScABY0yFMcYBFAF3+DYwxhwyxuwE3P46iDf2M/63gAh0vDMVJVtJsFjIGzch6HMays/gOtdI+mUyCgZ656NSSqnuKZpJ2CDgC5/Hld5jl6z0bP9bQAQ6HsieTetZ+vB9FL+1HElI4PPSbUGfa/+4ioTMZHpc1btLrxmPXC4X77//fsDn9c5HpZRSlzMxxnTeKpSOReYBtxhjHvA+vhuYZIz5vp+2LwN/DrQmTEQWA4sB+vfvP6GoqCis2Ox2e0i1n6oPuTm6FfC5ZGKBnImQlRdcPmvbt5vDG9dhfO7yk8REhkydSe8R7Rfn+8aaWA95H1iwDXNzdlh0/t3C0ZXrWldXx549e7Db7WRmZmK323G7LwyIJiQkMHLkSPr3D+/u00jEGmsaa3RorNGhsUZHPMeakZHRsp1Dd1dSUsLy5cvJz89vKW80ffr0EmNMob/20VyYXwn47j6aCxwLpSNjzFJgKUBhYaGZNm1aWIFt2LCBUPt4uXwzDfYmXE5DenYKk+8o6NKi/KV/fKVVAgZgnE5sn2xj7uK/7TDW6rc/x55Qyeh5N2DpGX8bswa6rm3vahwyZAi7d+8mKSmJ+fPnc/XVV1/0Ox/D+T9wsWms0aGxRofGGh3xHGtJSUmsQ4grOTk5jB49msmTJ3faNppJ2DZguIgMBY4CC4G7ovh6UXemqo66agdTFoxgzPTckPqotZ3u0vFmpslN/fbjXHF177hMwAJpe+fjuXPn2LlzJ/369ePuu+8mIyMD0DsflVJKdT9RWxNmjHECjwBrgT3Am8aYz0TkaRGZAyAiE0WkEpgH/FZEPotWPJFQUebZoLXgur4h95HRu0+Xjjer33UKd73zktuWItCdj42NjS0JmFJKKRWulStXIiKUl5dHvO/6+npuu+02Ro0axTXXXMOTTz4ZkX6juTAfY8zbxpgRxpgCY8wz3mM/M8as9n69zRiTa4xJM8b0NsZcE814wnWg9BQDC3qSFkaNxklz5rY7FsxuwXUfV5HY5wpSCrJCfu1Y0DsflVJK+aorO0nVs8VUPrmJqmeLqfMOcITLarVSWFhIuOvGA3niiScoLy+nrKyMDz/8kHfeeSfsPqOahF1Oqk/UY6u0UzA+vNJApyu/ABHSemWDCBl9+jJz8SMdblznOGbHcaSWtBsGBl1fMh7YbDYSEvz/F9M7H5VSqvupKztJ9Yr9uKo9Wzu5qhupXrE/7ETMbrezceNGXnrpJaxWayRCbSU1NZXp0z2f08nJyYwfP57Kysqw+9WyRUE66P0Pkh/GVOTZqqPs+uu7jL15FjPufyjo8+o+rkKSEkgLMwG8mHbt2sWaNWtISEhARHC5XC3Pac1HpZS6PFWvOYjjWF3A5x1HasDV+u5+0+Tm7PJ91BUf93tOck4aWbMLOnzdVatWMWPGDMaMGUNaWhqlpaWMHz++XbtgC3h3pLq6mjVr1vDYY48F1b4jmoQF6WDpKfoPzSQju0fIfWwueg1LYhKT5y4M+hxxQv2Ok1wxpi8JqfG5e7zvnY2lpaUtdR8HDx7M3LlzOXLkiNZ8VEop1S4B6/R4kKxWK4sXLwZg/vz5WK1Wv0lYsAW8A3E6nSxatIhHH32U/PzwazdrEhaEmtPnOXWkli99Y1jIfVQd2Mu+jzcz+ZuLSMvqFfR5mUcF43DH7Q75HdV9XLBgARaLhaysLE26lFKqG+hsxKrq2eKWqUhflqwU+n0vtM8Jm81GcXExK1asAGDBggVMnTqVJUuWtFvCE+xImMvlatn7bM6cOTz99NMALF68mOHDh/P444+HFGtbmoQF4WDpKQAKxoc2FWmMYdMbL5PaM4vC2+8M6py6spPUrD1En2oBi9B0+jzJg+PvbsKO6j5aLJYYRKSUUipeZd6SR/WK/ZimC5tzS1ICmbfkhdzn8uXLmTVrFikpnpvmhg4dyoABA9i8eTNTpkxp1TbYkTCLxcKOHTtaHfvJT37CuXPnePHFF0OOtS1NwoJwsOwkfa/MIDPEgtmHdpTwxe5dfPW7D5J8RWqn7ZsXLpomN4KAy1C9Yj8AadfF17owvftRKaVUsJo/w2rWHsJV3YglK4XMW/LC+myzWq3s3LmTvLy8lmM2m41ly5a1S8JCVVlZyTPPPMOoUaNapjkfeeQRHnjggbD61SSsE7VnGjjxeQ03fD20uV+328UHy14mq/9Axtx0S1Dn1Kw91Oq3BPAsXKxZeyiukrD9+/cjIvgrfaV3PyqllPIn7bp+Ef0s27BhQ8T6CiQ3N9fvZ124NAnrREWZdyoyxP8wezZt4PSRQ9z++N9jSQxuYb2/+fKOjl9sDoeD9957j23btpGRkcH58+dx+pRi0rsflVJKqc5pEtaJg6Un6T0onaz+nU8jtuV0OPjwD6/TP384I67/ctDnJWQk4a5tv87KEsYmsaFqW9Nx/Pjx7Nq1i9OnT3PDDTdw0003sWfPHr37USmllOoiTcI6UFfdSFXFOSbdPjSk88vW/pla2ylu/dsfIAE2LW3LZXdgnO52x8NduBgKf3Uf169fT0pKCnfffTcFBZ67YJrrPsZzgVmllFIq3mgS1oGKHafA0OVd8vdsWs8H1lew205jSUqm7qwtqPOM043t9T2YJkPGzVdSv+0EzuoGErN6hL1wMRSB7nxMSUlpScCUUkopFRpNwjpwsPQkvQamkT0wLehz9mxaz7qlL+B0eEsyNDlYt/QFgA5LExljqF59EMehGrIXjiR1XD963jTEO7o0KbxvJESB7nCsqam5yJEopZRSlx+tHRlAfY2DY/uru7w32KaiV1sSsGZORyObil7t8Ly6LVXUFR8nY9pgUsfF/g5IYww9evivDqB3PiqllFLh0yQsgIodpzAGhnVhKtLtclF7+pTf52ptpwOe13DgLNV/PkiPq7LJnDmky7FGWlNTEytWrKChoaHdbsN656NSSql4tHLlSkSE8vLyqPQ/bdo0Ro4cybhx4xg3bhwnT4ZXdBx0OjKgg6UnyeqfSnZOcFOR9eeq+cuvlwR8PqN3H7/Hm06fx/ZGOYl9U8leOBJJEL/tLpbq6mqKioo4fvw406dPJysri/fff1/vfFRKKRURbe+6j9TnitVqpbCwkKKiIp566qnwA/XjjTfeoLCwMGL9aRLmx3m7g6P7qhk/88p2I0H+HNtXzprn/pWG2lquvelW9mxa32pKMjE5hSkL72l53FySyFXdCAkCFuhzz9UkpFz8fw7fH4a0tDQcDgcJCQksWrSIkSNHAjB27NiLHpdSSqnLj7+77tesWQMQViJmt9vZuHEj7733HvPmzYtaEhZpUf3UF5Fbgf8ALMCLxphn2zyfArwKTABswAJjzKFoxtSRVUteZZ+9knpxkNonmcrPDsHXW98FuO63f2DH0YOeNiaZ/JRMvvjsf8no04dF//xv9MvLB9O3VZtrBxW0LMqvKzvJ9pUfsI0D2FMaSDc9KDQF9DpSS2LvC2WRfJOjsrKydr8pBPObRGdt2v4w1NXVAXDzzTe3JGBKKaVUsN555x2OHz8e8PnKykpcLlerY01NTbz11luUlJT4PWfAgAF87Wtf6/B1V61axYwZMxgzZgxpaWmUlpa2lBfyFWwB70Duu+8+LBYLc+fO5Sc/+UlQAzUdiVoSJiIW4DfAzUAlsE1EVhtjdvs0ux84a4wZJiILgV8AC6IVU0dWLXmVXXWHcCV49uiqFwd7HF+wasmrfP1HnlGsdb/9A1uP7W3T5gxDh0zkmz9+jB7p6WxbvZniY3tx+rQpPraXrBUbufaaa9n+1gd8ILtxied5uzSwyewh4S+J3Hidp7h3Z78pBPObREdtrr32Wux2O2vXrvW7BUVxcTFf/nLwm8sqpZRSwWibgHV2PFhWq5XFixcDMH/+fKxWq98kLNgC3v688cYbDBo0iNraWubOnctrr73GPffc0/mJHYjmSNgk4IAxpgJARIqAOwDfJOwO4Cnv18uBF0RETDQKNHVin72yJblq5hI3e+xH6PXqWwCUHNvfkjz5tvkiOYF9W/YA8NfSjTjbtHGKm/c/2UzTdhtbkvb67eOjpt30K78KgHfffbddctTU1MS7775LcnJyh88nJiZ22MeqVataJWf+aPFtpZRSoehsxOq5557z+xnTs2dP7rvvvpBe02azUVxczIoVKwBYsGABU6dOZcmSJe1GqoIdCXO5XEyYMAGAOXPm8PTTTzNo0CAAMjIyuOuuuyguLg47CZNo5Tsi8k3gVmPMA97HdwPXG2Me8WnzqbdNpffxQW+b0236WgwsBujfv/+EoqKisGKz2+2kp6e3OrZh/QaI7Zr4iyY3N5cePXpw+PDhgJuxTp48ucv9+ruu8UpjjQ6NNTo01ujQWCMjIyOjJWHpTNtZGvDcdT979uyQ14T99re/5aOPPuKVV15pOTZp0iR+9atfMWXKlJD6bMvpdFJdXU2fPn1oampi0aJFzJgxgwcffLBVu5KSEpYvX05+fj7Dhw8HYPr06SXGGL+r+aM5EuYvpWmb8QXTBmPMUmApQGFhoQm3NI6/8jrF739EvTjate3hTuK2KZ62f9m0gYaE9klLD3cSd81dCIB15R84T/t+riCFuxffyxuvvE5dY32759NSUvnWvd8GYNmyZdjt9nZt0tPTueuuuzp8/tvf9vTx+uuv+23Ts2dPHnjgASDwD8Ntt90W0g/DpVS2SGONDo01OjTW6NBYIyPQWi5/mj9bInl3pNVqZefOneTl5bUcs9lsLFu2LGJJWGNjI7fccgtNTU24XC5mzJjB3/zN3/htm5OTw+jRo4MazIhmElYJDPZ5nAscC9CmUkQSgZ7AmSjGFNCI9FzPmjCfqUKLSWBU+mCuvdmzPqqqotKzJqxNm/GDhnHlWM8C/q8evpG1Je+3mpJMNAl8dcIUcnJyuOW2W1n91mqcLueF5y2J3HLbreTk5AAwc+ZMv8nRzJkzycnJ6fD5AQMGdNiH7x5f0fhhUEoppTrSXG84UjZs2BCxvgJJS0vrUrIZrGgmYduA4SIyFDgKLATuatNmNXAvsAX4JvB+LNaDAZ7F9753R5pkRqTntizKB5j5vQXQ5u7IcYMKPMe9Js75CgAbSzdjNw2kSw+mTvhKy/FgEp/O2kSiD992mnQppZRSF1/UkjBjjFNEHgHW4tmi4nfGmM9E5GlguzFmNfAS8JqIHMAzArYwWvEEwzfhCmTm9xYws5M2E+dcSLr8CSbxaW4TaAi6K30opZRSKv5EdZ8wY8zbwNttjv3M5+sGYF40Y1BKKaWUikdaO1IppZRSYXG73Z03usyFcg00CVNKKaVUyFJTU6mqqurWiZjb7eb48eM0NTXRlaXtWjtSKaWUUiErKCigtLSUqqqqsMv4XMqamppa9t/MzMwM6hxNwpRSSikVsuTkZAoKCvjTn/6Ew+Hg+PHjLdslxbtIx+p2u1tt1NoZTcKUUkopFZa+fftyzz33UF1dzccff8ykSZNiHVJQiouLIxprUlISvXv3bikh2BlNwpRSSikVttTUVFJTU8nOziY3NzfW4QTlwIEDMY1VF+YrpZRSSsVA1Ap4R4uInAIOh9lNH+B0p63ig8YaHRprdGis0aGxRofGGh0aa2tDjDF9/T1xySVhkSAi2wNVNI83Gmt0aKzRobFGh8YaHRprdGiswdPpSKWUUkqpGNAkTCmllFIqBrprErY01gF0gcYaHRprdGis0aGxRofGGh0aa5C65ZowpZRSSqlY664jYUoppZRSMdWtkjARuVVE9orIARF5MtbxdEREDonILhHZISLbYx1PWyLyOxE5KSKf+hzLFpH3RGS/9+9esYyxWYBYnxKRo97ru0NEZsUyRm9Mg0VkvYjsEZHPROQx7/G4u64dxBqP17WHiBSLyCfeWP+v9/hQEdnqva5/EJHkOI71ZRH53Oe6jot1rM1ExCIiZSLyZ+/juLuuzfzEGpfX1d/7fzy+D0DAWOPufQBARLJEZLmIlHvfuybH+rp2myRMRCzAb4CvAVcDi0Tk6thG1anpxphxcXqr78vArW2OPQn81RgzHPir93E8eJn2sQI8572+44wxb1/kmPxxAn9njLkKuAF42Pt/NB6va6BYIf6uayPwVWPMWGAccKuI3AD8Ak+sw4GzwP0xjLFZoFgB/o/Pdd0RuxDbeQzY4/M4Hq9rs7axQvxe17bv//H4PtDM32dVvL0PAPwH8K4xZhQwFs//hZhe126ThAGTgAPGmApjjAMoAu6IcUyXLGPMB8CZNofvAF7xfv0K8PWLGlQAAWKNO8aYKmNMqffrWjxvEIOIw+vaQaxxx3jYvQ+TvH8M8FVgufd4vFzXQLHGJRHJBW4DXvQ+FuLwukL7WC9Bcfc+cCkRkUzgRuAlAGOMwxhTTYyva3dKwgYBX/g8riROPzS8DLBOREpEZHGsgwlSf2NMFXg+pIF+MY6nM4+IyE7vdGVcDO03E5E84DpgK3F+XdvECnF4Xb3TUDuAk8B7wEGg2hjj9DaJm/eDtrEaY5qv6zPe6/qciKTEMERfzwM/Atzex72J0+tK+1ibxeN19ff+H6/vA4E+q+LtfSAfOAX83jsl/aKIpBHj69qdkjDxcyxuf8MEvmyMGY9n+vRhEbkx1gFdZv4bKMAz5VMF/Cq24VwgIunAn4DHjTE1sY6nI35ijcvraoxxGWPGAbl4RsWv8tfs4kblX9tYRWQ08A/AKGAikA38fQxDBEBEbgdOGmNKfA/7aRrz6xogVojD6+p1Kb3/+4s1Ht8HEoHxwH8bY64D6oiDKd3ulIRVAoN9HucCx2IUS6eMMce8f58EVuL54Ih3J0RkIID375MxjicgY8wJ74edG/gf4uT6ikgSnqTmDWPMCu/huLyu/mKN1+vazDv9sAHPOrYsEUn0PhV37wc+sd7qnf41xphG4PfEx3X9MjBHRA7hWd7xVTyjTfF4XdvFKiKvx+l1DfT+H5fvA/5ijdP3gUqg0mdkeTmepCym17U7JWHbgOHeO3eSgYXA6hjH5JeIpIlIRvPXwEzg047PigurgXu9X98LvBXDWDrU/EPndSdxcH2962leAvYYY/7d56m4u66BYo3T69pXRLK8X18BzMCzhm098E1vs3i5rv5iLff5kBA8a1Zifl2NMf9gjMk1xuTheT993xjzLeLwugaI9dvxeF07eP+Px/cBv7HG4/uAMeY48IWIjPQeugnYTYyva2LnTS4PxhiniDwCrAUswO+MMZ/FOKxA+gMrPe8LJALLjDHvxjak1kTECkwD+ohIJfBz4FngTRG5HzgCzItdhBcEiHWaeG5HN8Ah4HsxC/CCLwN3A7u8a4IA/pH4vK6BYl0Uh9d1IPCK9w7pBOBNY8yfRWQ3UCQi/wyU4V2wG2OBYn1fRPrime7bATwYyyA78ffE33UN5I04vK5+3/9FZBvx9z4QKNbX4vB9AOD7eP7Nk4EK4D68P2exuq66Y75SSimlVAx0p+lIpZRSSqm4oUmYUkoppVQMaBKmlFJKKRUDmoQppZRSSsWAJmFKKaWUUjGgSZhSqstExIjIr3wePyEiT0Wo75dF5Judtwz7deaJyB4RWd/meJ6InPeWNtkjIsUicm+gftqca/WWavlBBOK7KNdBKRU73WafMKVURDUC3xCRfzXGnI51MM1ExGKMcQXZ/H7gb40x6/08d9Bb2gQRyQdWiEiCMeb3Hbz2AOBLxpghXQ48AkQk0admo1LqEqAjYUqpUDiBpUC7EZ+2IzgiYvf+PU1ENorImyKyT0SeFZFveUeadolIgU83M0Rkk7fd7d7zLSLySxHZ5h1t+p5Pv+tFZBmwy088i7z9fyoiv/Ae+xnwFeD/icgvO/pGjTEVwA+BR73npomnKPE272jZHd6m64B+IrJDRKaISIGIvCuewsabRGSUz/X5tYh8JCIVzddKPF4Qkd0i8hd8CgmLyATvtSsRkbU+O71vEJF/EZGNwGPe0b1PReQTEfmgo+9LKRV7OhKmlArVb4CdIrKkC+eMxVM8+wyeHatfNMZMEpHH8Oxm/bi3XR4wFU8R4PUiMgy4BzhnjJkoIinAhyKyztt+EjDaGPO574uJSA7wC2ACcBZYJyJfN8Y8LSJfBZ4wxmwPIu5SPIWeAX6Mp+zNd8VTYqhYRP4XmAP82Vt8GxH5K/CgMWa/iFwP/Bee+org2Rn/K94+V+OpY3cnMBK4Fs9O5LuB34mnRud/AncYY06JyALgGeC73r6yjDFTva+5C7jFGHPUG5tSKo5pEqaUCokxpkZEXsUzQnQ+yNO2GWOqAETkIJ7RI/CMYE33afemt/jvfhGpwJOszATG+Iyy9QSGAw6guG0C5jUR2GCMOeV9zTeAG4FVQcbbTHy+nomnGPQT3sc9gCvxuQYikg58Cfijt6QLQIpPH6u8399uEenvPXYjYPVOpx4Tkfe9x0cCo4H3vH1ZgCqfvv7g8/WHwMsi8iawAqVUXNMkTCkVjufxjBL5rpVy4l3qIJ6sIdnnuUafr90+j920fj9qW0/N4EmEvm+MWev7hIhMA+oCxCcBjnfVdXiKfjf3OdcYs7dNHHk+DxOA6uZRMT98r4NvjP7qyAnwmTFmcoC+Wr53Y8yD3lG324AdIjLOGGMLcJ5SKsZ0TZhSKmTGmDPAm3gWuTc7hGf6D+AOICmErueJSIJ3nVg+sBdYCzzknZ5DREaISFon/WwFpopIH/EUxV4EbOxKIN7k6t/wTAnijeP73gQTEbmu7TnGmBrgcxGZ520jIjK2k5f6AFjoXfs2kAsjg3uBviIy2dtXkohcEyDWAmPMVmPMz4DTwODgv1Ol1MWmI2FKqXD9CnjE5/H/AG+JSDHwVwKPUnVkL55kqT+edVUNIvIinrVipd4E6BTw9Y46McZUicg/AOvxjCi9bYx5K4jXLxCRMjxTjbXAf/rcGflPeEYAd3rjOATc7qePbwH/LSI/wZOIFgGfdPCaK/GsGdsF7MObLBpjHN4p2F+LSE8879vPA5/56eOXIjLc+73+tZPXU0rFmBjjb/RbKaWUUkpFk05HKqWUUkrFgCZhSimllFIxoEmYUkoppVQMaBKmlFJKKRUDmoQppZRSSsWAJmFKKaWUUjGgSZhSSimlVAxoEqaUUkopFQP/H9T/f2a126MuAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "chart()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the purple line (fourth from bottom), where the number of attackers exactly equals the number of defenders, gives a low win probability for a small attacking force, but reaches 50% for 12-on-12, and 73% for 60-on-60. The red line, where the attackers have one more army than the defenders, dips from one to two defenders but is over 50% for a 6-on-5 attack. Similarly, the green line, where the attackers have a surplus of two armies, dips sharply from 75% to 66% as the number of defenders goes from 1 to 2, dips slightly more for 3 and 4 defenders, and then starts to rise. So overall, an attacker does not need a big advantage in armies as long as there are many armies on both sides. Even when the attacker is at a disadvantage in numbers (as in the bottom grey line where the attacker has five fewer armies), the attacker still has bettern than 50/50 odds with 45 attackers or more."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tests\n",
    "\n",
    "Here are regression unit tests that also serve as examples of usage."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Tests for States\n",
    "assert A(start)  == 72\n",
    "assert D(start)  == 22 \n",
    "assert allD(start) == (22, 8, 2, 2, 2, 7, 1, 1, 3, 1, 2, 3, 5, 1)\n",
    "assert sum(allD(start)) == 60 \n",
    "assert len(allD(start)) == 14\n",
    "\n",
    "# Tests for update\n",
    "small = State((10, 2, 5)) # Small example where 10 attackers battle 2, then 5 dfenders\n",
    "assert update(small, (0, 2)) == (9, 5)    # 2 defenders dead; occupy the first territory\n",
    "assert update(small, (1, 1)) == (9, 1, 5) # continue to battle\n",
    "assert update(small, (2, 0)) == (8, 2, 5) # continue to battle\n",
    "assert update(start, (1, 1)) == (71, 21, 8, 2, 2, 2, 7, 1, 1, 3, 1, 2, 3, 5, 1)\n",
    "assert update((9, 2), (0, 2)) == (8,) # Attackers occupied the final territory\n",
    "\n",
    "# The 4 sample dice rolls from www.ultraboardgames.com/risk/game-rules.php\n",
    "assert battle_deaths([1, 1, 6], [3,])   == (0, 1) # Defender loses one\n",
    "assert battle_deaths([2, 6, 1], [2, 3]) == (1, 1) # Both lose one\n",
    "assert battle_deaths([3, 3],    [3, 4]) == (2, 0) # Attacker loses two\n",
    "assert battle_deaths([6,],      [5, 4]) == (0, 1) # Defender loses one\n",
    "\n",
    "# All six possible battle dice combinations. The answers match those given at\n",
    "# a Risk data analysis blog: http://datagenetics.com/blog/november22011/\n",
    "assert battle_deaths_probdist((1, 1)) == ProbDist({(1, 0):   21, (0, 1):   15})\n",
    "assert battle_deaths_probdist((2, 1)) == ProbDist({(1, 0):   91, (0, 1):  125})\n",
    "assert battle_deaths_probdist((3, 1)) == ProbDist({(1, 0):  441, (0, 1):  855})\n",
    "assert battle_deaths_probdist((1, 2)) == ProbDist({(1, 0):  161, (0, 1):   55})\n",
    "assert battle_deaths_probdist((2, 2)) == ProbDist({(2, 0):  581, (1, 1):  420, (0, 2):  295})\n",
    "assert battle_deaths_probdist((3, 2)) == ProbDist({(2, 0): 2275, (1, 1): 2611, (0, 2): 2890})\n",
    "\n",
    "assert set(all_rolls(2)) == {(1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), \n",
    "                         (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), \n",
    "                         (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), \n",
    "                         (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), \n",
    "                         (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), \n",
    "                         (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6)}\n",
    "\n",
    "assert attacker_win_probability(campaign_probdist((2, 1))) == 15/36\n",
    "assert campaign_probdist((2, 1)) == ProbDist({(1, 1): 21/36, (1,): 15/36})\n",
    "assert campaign_probdist((4, 2, 1)) == ProbDist(\n",
    "    {(1, 2, 1): 0.21807067805974698,\n",
    "     (1, 1, 1): 0.12597532213712342,\n",
    "     (1, 1): 0.294669783648961,\n",
    "     (1,): 0.14620529335276633,\n",
    "     (2,): 0.21507892280140226})\n",
    "\n",
    "assert battle_update_probdist(ProbDist({start: 1})) == ProbDist(\n",
    "    {(70, 22, 8, 2, 2, 2, 7, 1, 1, 3, 1, 2, 3, 5, 1): 0.2925668724279835,\n",
    "     (71, 21, 8, 2, 2, 2, 7, 1, 1, 3, 1, 2, 3, 5, 1): 0.3357767489711934,\n",
    "     (72, 20, 8, 2, 2, 2, 7, 1, 1, 3, 1, 2, 3, 5, 1): 0.37165637860082307})\n",
    "\n",
    "True"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
